From 35328554bd80c04c4e8a80c8b3a5ea51c89d0b2a Mon Sep 17 00:00:00 2001 From: xinxin13 Date: Fri, 30 Dec 2022 20:15:36 +0800 Subject: [PATCH 1/5] add mix stack dumper tdd test code Signed-off-by: xinxin13 --- .../BUILD.gn | 8 +- .../mix_stack_dumper_test.cpp | 190 +++++++++++++++++- 2 files changed, 194 insertions(+), 4 deletions(-) diff --git a/test/unittest/frameworks_kits_appkit_native_test/BUILD.gn b/test/unittest/frameworks_kits_appkit_native_test/BUILD.gn index 0f67ecd9e5d..5d2c280a562 100644 --- a/test/unittest/frameworks_kits_appkit_native_test/BUILD.gn +++ b/test/unittest/frameworks_kits_appkit_native_test/BUILD.gn @@ -326,7 +326,10 @@ ohos_unittest("mix_stack_dumper_test") { "${ability_runtime_test_path}/mock/frameworks_kits_runtime_test/", ] - sources = [ "mix_stack_dumper_test.cpp" ] + sources = [ + "${ability_runtime_native_path}/appkit/app/mix_stack_dumper.cpp", + "mix_stack_dumper_test.cpp", + ] deps = [ "${ability_runtime_native_path}/appkit:appkit_native", @@ -336,7 +339,10 @@ ohos_unittest("mix_stack_dumper_test") { external_deps = [ "ability_runtime:abilitykit_native", "ability_runtime:runtime", + "c_utils:utils", "faultloggerd:lib_dfx_dump_catcher", + "faultloggerd:libfaultloggerd", + "hiviewdfx_hilog_native:libhilog", ] } diff --git a/test/unittest/frameworks_kits_appkit_native_test/mix_stack_dumper_test.cpp b/test/unittest/frameworks_kits_appkit_native_test/mix_stack_dumper_test.cpp index 81dbe2c1811..238f3553366 100644 --- a/test/unittest/frameworks_kits_appkit_native_test/mix_stack_dumper_test.cpp +++ b/test/unittest/frameworks_kits_appkit_native_test/mix_stack_dumper_test.cpp @@ -14,7 +14,6 @@ */ #include - #include #include #include @@ -22,18 +21,26 @@ #include #include #include - #define private public +#define protected public #include "mix_stack_dumper.h" #undef private +#undef protected +#include "hilog_wrapper.h" #include "mock_runtime.h" - +#include "runtime.h" using namespace testing::ext; using namespace OHOS; using namespace OHOS::AppExecFwk; namespace OHOS { namespace AppExecFwk { +namespace { + constexpr int32_t ZERO = 0; + constexpr int32_t ONE = 1; + constexpr int32_t NATIVE_DUMP = -1; + constexpr int32_t MIX_DUMP = -2; +} class MixStackDumperTest : public testing::Test { public: static void SetUpTestCase(); @@ -265,5 +272,182 @@ HWTEST_F(MixStackDumperTest, MixStackDumperTest007, Function | MediumTest | Leve EXPECT_TRUE(CheckMixStackKeyWords(testFile, headerKeywords, length)); } } + +/** + * @tc.number: MixStackDumperTest008 + * @tc.name: dump com.ohos.systemui process + * @tc.desc: try to dump com.ohos.systemui process, must be failed. + */ +HWTEST_F(MixStackDumperTest, MixStackDumperTest008, Function | MediumTest | Level3) +{ + MixStackDumper mixDumper; + mixDumper.Destroy(); + pid_t pid = GetServicePid("com.ohos.systemui"); + mixDumper.Init(pid); + bool ret = mixDumper.DumpMixFrame(1, pid, pid); + mixDumper.Destroy(); + mixDumper.HandleMixDumpRequest(); + EXPECT_FALSE(ret); +} + +/** + * @tc.number: MixStackDumperTest009 + * @tc.name: test DumpMixFrame Func + * @tc.desc: dump current process which is not a applicaiton process + */ +HWTEST_F(MixStackDumperTest, MixStackDumperTest009, Function | MediumTest | Level3) +{ + MixStackDumper mixDumper; + bool ret = mixDumper.DumpMixFrame(1, getpid(), getpid()); + EXPECT_FALSE(ret); + mixDumper.Init(getpid()); + ret = mixDumper.DumpMixFrame(1, -1, -1); + EXPECT_FALSE(ret); + ret = mixDumper.DumpMixFrame(1, getpid(), getpid()); + mixDumper.Destroy(); + EXPECT_TRUE(ret); +} + +/** + * @tc.number: MixStackDumperTest0010 + * @tc.name: Call BuildJsStackInfoList Func + * @tc.desc: test JsRuntime BuildJsStackInfoList Func + */ +HWTEST_F(MixStackDumperTest, MixStackDumperTest010, Function | MediumTest | Level3) +{ + AbilityRuntime::MockRuntime runtime; + std::vector frames; + bool ret = runtime.BuildJsStackInfoList(gettid(), frames); + EXPECT_TRUE(ret); +} + +/** + * @tc.number: MixStackDumperTest011 + * @tc.name: Call PrintNativeFrames Func + * @tc.desc: test PrintNativeFrames Func and GetThreadStackTraceLabel Func + */ +HWTEST_F(MixStackDumperTest, MixStackDumperTest011, Function | MediumTest | Level3) +{ + std::shared_ptr nativeFrame1 = std::make_shared(); + nativeFrame1->SetFrameMapName("testmapname"); + std::shared_ptr nativeFrame2 = std::make_shared(); + std::vector> nativeFrames; + nativeFrames.emplace_back(nativeFrame1); + nativeFrames.emplace_back(nativeFrame2); + nativeFrames.emplace_back(nullptr); + MixStackDumper mixDumper; + mixDumper.PrintNativeFrames(ONE, nativeFrames); + EXPECT_TRUE(true); + std::string label = mixDumper.GetThreadStackTraceLabel(gettid()); + EXPECT_TRUE(label != ""); +} + +/** + * @tc.number: MixStackDumperTest012 + * @tc.name: Call GetThreadList Func + * @tc.desc: test GetThreadList Func + */ +HWTEST_F(MixStackDumperTest, MixStackDumperTest012, Function | MediumTest | Level3) +{ + MixStackDumper mixDumper; + std::vector threadList; + EXPECT_TRUE(threadList.empty()); + mixDumper.GetThreadList(threadList); + EXPECT_FALSE(threadList.empty()); +} + +/** + * @tc.number: MixStackDumperTest013 + * @tc.name: Call DumpMixFrame Func + * @tc.desc: test DumpMixFrame Func + */ +HWTEST_F(MixStackDumperTest, MixStackDumperTest013, Function | MediumTest | Level1) +{ + std::shared_ptr mixDumper = std::make_shared(); + std::shared_ptr ohosApplication = std::make_shared(); + mixDumper->application_ = ohosApplication; + auto application = mixDumper->application_.lock(); + EXPECT_TRUE(application); + mixDumper->Init(getpid()); + mixDumper->DumpMixFrame(ONE, getpid(), getpid()); + std::unique_ptr mockRuntime = std::make_unique(); + application->runtime_ = std::move(mockRuntime); + EXPECT_TRUE(application->GetRuntime()); + mixDumper->Init(getpid()); + bool ret = mixDumper->DumpMixFrame(ONE, getpid(), getpid()); + EXPECT_TRUE(ret); + mixDumper->catcher_->procInfo_.tid = ZERO; + EXPECT_EQ(mixDumper->catcher_->procInfo_.tid, ZERO); + mixDumper->DumpMixFrame(ONE, ZERO, getpid()); + mixDumper->application_.reset(); +} + +/** + * @tc.number: MixStackDumperTest014 + * @tc.name: Call BuildJsNativeMixStack Func + * @tc.desc: test BuildJsNativeMixStack Func + */ +HWTEST_F(MixStackDumperTest, MixStackDumperTest014, Function | MediumTest | Level1) +{ + MixStackDumper mixDumper; + std::vector> v_nativeFrames; + struct JsFrames jsFrames; + jsFrames.fileName = "fileName"; + jsFrames.functionName = "functionName"; + jsFrames.pos = "pos"; + jsFrames.nativePointer = nullptr; + std::vector v_jsFrames; + EXPECT_TRUE(v_jsFrames.size() == ZERO); + mixDumper.BuildJsNativeMixStack(ONE, v_jsFrames, v_nativeFrames); + v_jsFrames.push_back(jsFrames); + EXPECT_TRUE(v_jsFrames.size() > ZERO); + EXPECT_TRUE(v_jsFrames[ZERO].nativePointer == nullptr); + mixDumper.BuildJsNativeMixStack(ONE, v_jsFrames, v_nativeFrames); + v_jsFrames.clear(); + unsigned int data = 10; + jsFrames.nativePointer = &data; + v_jsFrames.push_back(jsFrames); + EXPECT_TRUE(v_jsFrames.size() > ZERO); + EXPECT_TRUE(v_jsFrames[ZERO].nativePointer != nullptr); + mixDumper.BuildJsNativeMixStack(ONE, v_jsFrames, v_nativeFrames); + EXPECT_TRUE(v_nativeFrames.size() == ZERO); + mixDumper.BuildJsNativeMixStack(ONE, v_jsFrames, v_nativeFrames); + std::shared_ptr dfxFrame = std::make_shared(); + dfxFrame->pc_ = (uint64_t)(v_jsFrames[ZERO].nativePointer); + v_nativeFrames.push_back(dfxFrame); + bool ret1 = mixDumper.IsJsNativePcEqual(v_jsFrames[ZERO].nativePointer, v_nativeFrames[ZERO]->GetFramePc(), + v_nativeFrames[ZERO]->GetFrameFuncOffset()); + EXPECT_TRUE(ret1); + mixDumper.BuildJsNativeMixStack(ONE, v_jsFrames, v_nativeFrames); + dfxFrame->pc_ = ZERO; + v_nativeFrames.push_back(dfxFrame); + bool ret2 = mixDumper.IsJsNativePcEqual(v_jsFrames[ZERO].nativePointer, v_nativeFrames[ZERO]->GetFramePc(), + v_nativeFrames[ZERO]->GetFrameFuncOffset()); + EXPECT_FALSE(ret2); + mixDumper.BuildJsNativeMixStack(ONE, v_jsFrames, v_nativeFrames); +} + +/** + * @tc.number: MixStackDumperTest015 + * @tc.name: Call Dump_SignalHandler Func + * @tc.desc: test Dump_SignalHandler Func + */ +HWTEST_F(MixStackDumperTest, MixStackDumperTest015, Function | MediumTest | Level1) +{ + MixStackDumper mixDumper; + siginfo_t sign; + sign.si_code = NATIVE_DUMP; + mixDumper.Dump_SignalHandler(ZERO, &sign, nullptr); + sign.si_code = ZERO; + mixDumper.Dump_SignalHandler(ZERO, &sign, nullptr); + sign.si_code = MIX_DUMP; + mixDumper.Dump_SignalHandler(ZERO, &sign, nullptr); + std::shared_ptr eventHandler = std::make_shared(); + mixDumper.signalHandler_ = eventHandler; + auto handler = mixDumper.signalHandler_.lock(); + EXPECT_TRUE(handler); + mixDumper.Dump_SignalHandler(ZERO, &sign, nullptr); + mixDumper.signalHandler_.reset(); +} } // namespace AppExecFwk } // namespace OHOS -- Gitee From 1146213946bcac01c18f904985b5185286d8a504 Mon Sep 17 00:00:00 2001 From: xinxin13 Date: Fri, 30 Dec 2022 20:22:14 +0800 Subject: [PATCH 2/5] add ohos application tdd test code Signed-off-by: xinxin13 --- .../native/appkit/app/ohos_application.cpp | 3 +- .../include/mock_element_callback.h | 5 + .../mock_runtime.h | 25 +- test/unittest/appkit/BUILD.gn | 5 +- .../appkit/ohos_application_test/BUILD.gn | 89 ++ .../ohos_application_test.cpp | 1292 +++++++++++++++++ 6 files changed, 1407 insertions(+), 12 deletions(-) create mode 100644 test/unittest/appkit/ohos_application_test/BUILD.gn create mode 100644 test/unittest/appkit/ohos_application_test/ohos_application_test.cpp diff --git a/frameworks/native/appkit/app/ohos_application.cpp b/frameworks/native/appkit/app/ohos_application.cpp index 4017457d696..cc45a9d2137 100644 --- a/frameworks/native/appkit/app/ohos_application.cpp +++ b/frameworks/native/appkit/app/ohos_application.cpp @@ -537,7 +537,8 @@ std::shared_ptr OHOSApplication::AddAbilityStage( } if (abilityInfo->applicationInfo.multiProjects) { - auto rm = stageContext->CreateModuleContext(hapModuleInfo->moduleName)->GetResourceManager(); + auto moduleContext = stageContext->CreateModuleContext(hapModuleInfo->moduleName); + auto rm = moduleContext != nullptr ? moduleContext->GetResourceManager() : nullptr; stageContext->SetResourceManager(rm); } diff --git a/test/mock/frameworks_kits_appkit_native_test/include/mock_element_callback.h b/test/mock/frameworks_kits_appkit_native_test/include/mock_element_callback.h index b047026e2d6..caf83071676 100644 --- a/test/mock/frameworks_kits_appkit_native_test/include/mock_element_callback.h +++ b/test/mock/frameworks_kits_appkit_native_test/include/mock_element_callback.h @@ -36,6 +36,7 @@ public: virtual void OnConfigurationUpdated(const std::shared_ptr& ability, const Configuration& config) { GTEST_LOG_(INFO) << "MockElementsCallback::OnConfigurationUpdated called"; + configurationUpdated_ = true; } /** @@ -47,7 +48,11 @@ public: virtual void OnMemoryLevel(int level) { GTEST_LOG_(INFO) << "MockElementsCallback::OnMemoryLevel called"; + onMemoryLevel_ = true; } + + bool configurationUpdated_ = false; + bool onMemoryLevel_ = false; }; } // namespace AppExecFwk } // namespace OHOS diff --git a/test/mock/frameworks_kits_runtime_test/mock_runtime.h b/test/mock/frameworks_kits_runtime_test/mock_runtime.h index 8dbd8098129..c7fed37a851 100644 --- a/test/mock/frameworks_kits_runtime_test/mock_runtime.h +++ b/test/mock/frameworks_kits_runtime_test/mock_runtime.h @@ -27,39 +27,44 @@ public: MockRuntime() = default; ~MockRuntime() = default; - bool BuildJsStackInfoList(uint32_t tid, std::vector& jsFrames) + Language GetLanguage() const override + { + return static_cast(100); + } + + bool BuildJsStackInfoList(uint32_t tid, std::vector& jsFrames) override { GTEST_LOG_(INFO) << "MockRuntime::BuildJsStackInfoList called"; return true; } - void StartDebugMode(bool needBreakPoint) {} - void FinishPreload() {} - bool LoadRepairPatch(const std::string& patchFile, const std::string& baseFile) + void StartDebugMode(bool needBreakPoint) override {} + void FinishPreload() override {} + bool LoadRepairPatch(const std::string& patchFile, const std::string& baseFile) override { return true; } - bool NotifyHotReloadPage() + bool NotifyHotReloadPage() override { return true; } - bool UnLoadRepairPatch(const std::string& patchFile) + bool UnLoadRepairPatch(const std::string& patchFile) override { return true; } - bool RunScript(const std::string& path, const std::string& hapPath) + bool RunScript(const std::string& path, const std::string& hapPath) override { return true; } - bool Initialize(const Options& options) + bool Initialize(const Options& options) override { return true; } void Deinitialize() {} - NativeValue* LoadJsBundle(const std::string& path, const std::string& hapPath) + NativeValue* LoadJsBundle(const std::string& path, const std::string& hapPath) override { return nullptr; } - NativeValue* LoadJsModule(const std::string& path, const std::string& hapPath) + NativeValue* LoadJsModule(const std::string& path, const std::string& hapPath) override { return nullptr; } diff --git a/test/unittest/appkit/BUILD.gn b/test/unittest/appkit/BUILD.gn index 74c48797b2b..8c55789719a 100644 --- a/test/unittest/appkit/BUILD.gn +++ b/test/unittest/appkit/BUILD.gn @@ -14,5 +14,8 @@ group("unittest") { testonly = true - deps = [ "main_thread_test:unittest" ] + deps = [ + "main_thread_test:unittest", + "ohos_application_test:unittest", + ] } diff --git a/test/unittest/appkit/ohos_application_test/BUILD.gn b/test/unittest/appkit/ohos_application_test/BUILD.gn new file mode 100644 index 00000000000..ecccb0dda0f --- /dev/null +++ b/test/unittest/appkit/ohos_application_test/BUILD.gn @@ -0,0 +1,89 @@ +# Copyright (c) 2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") +import("//build/test.gni") +import("//foundation/ability/ability_runtime/ability_runtime.gni") + +config("coverage_flags") { + if (ability_runtime_feature_coverage) { + cflags = [ "--coverage" ] + ldflags = [ "--coverage" ] + } +} + +ohos_unittest("ohos_application_test") { + module_out_path = "ability_runtime/appkit" + + include_dirs = [ + "${ability_runtime_path}/mock/services_appmgr_test/include", + "${ability_runtime_path}/interfaces/kits/native/appkit/app", + "${ability_runtime_path}/interfaces/kits/native/appkit/ability_runtime/context", + "${ability_runtime_path}/interfaces/kits/native/ability/native", + "${ability_runtime_test_path}/mock/frameworks_kits_runtime_test/", + "${ability_runtime_test_path}/mock/frameworks_kits_appkit_native_test/include", + "//base/notification/distributed_notification_service/frameworks/core/test/unittest/mock", + "//foundation/bundlemanager/bundle_framework/interfaces/inner_api/appexecfwk_base/include", + ] + + sources = [ "ohos_application_test.cpp" ] + + configs = [ + "${ability_runtime_services_path}/common:common_config", + ":coverage_flags", + ] + + cflags = [] + + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + + deps = [ + "${ability_runtime_native_path}/appkit:app_context", + "${ability_runtime_native_path}/appkit:appkit_native", + "//foundation/ability/ability_runtime/frameworks/native/ability/native:abilitykit_native", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + + external_deps = [ + "ability_base:configuration", + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_deps_wrapper", + "ability_runtime:ability_manager", + "ability_runtime:abilitykit_native", + "ability_runtime:app_manager", + "ability_runtime:runtime", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "common_event_service:cesfwk_innerkits", + "eventhandler:libeventhandler", + "faultloggerd:lib_dfx_dump_catcher", + "faultloggerd:libfaultloggerd", + "hisysevent_native:libhisysevent", + "hitrace_native:hitrace_meter", + "hiviewdfx_hilog_native:libhilog", + "init:libbegetutil", + "ipc:ipc_core", + "napi:ace_napi", + "samgr:samgr_proxy", + ] +} + +group("unittest") { + testonly = true + deps = [ ":ohos_application_test" ] +} diff --git a/test/unittest/appkit/ohos_application_test/ohos_application_test.cpp b/test/unittest/appkit/ohos_application_test/ohos_application_test.cpp new file mode 100644 index 00000000000..475a3b1e25a --- /dev/null +++ b/test/unittest/appkit/ohos_application_test/ohos_application_test.cpp @@ -0,0 +1,1292 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#define private public +#include "ability.h" +#include "ability_local_record.h" +#include "ability_record_mgr.h" +#include "ability_thread.h" +#include "application_context.h" +#include "application_impl.h" +#include "application_info.h" +#include "context_deal.h" +#include "context_impl.h" +#include "mock_ability_lifecycle_callbacks.h" +#include "mock_element_callback.h" +#include "mock_i_remote_object.h" +#include "mock_runtime.h" +#include "ohos_application.h" +#include "pac_map.h" +#include "runtime.h" +#undef private + +using namespace testing; +using namespace testing::ext; + +namespace OHOS { +namespace AppExecFwk { +class OHOSApplicationTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp() override; + void TearDown() override; + std::shared_ptr ohosApplication_; +}; + +void OHOSApplicationTest::SetUpTestCase() +{} + +void OHOSApplicationTest::TearDownTestCase() +{} + +void OHOSApplicationTest::SetUp() +{ + ohosApplication_ = std::make_shared(); +} + +void OHOSApplicationTest::TearDown() +{ + ohosApplication_ = nullptr; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_DispatchAbilitySavedState_0100 +* @tc.name: DispatchAbilitySavedState +* @tc.desc: Verify function DispatchAbilitySavedState list abilityLifecycleCallbacks_ empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_DispatchAbilitySavedState_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DispatchAbilitySavedState_0100 start."; + PacMap outState; + ohosApplication_->DispatchAbilitySavedState(outState); + EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DispatchAbilitySavedState_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_DispatchAbilitySavedState_0200 +* @tc.name: DispatchAbilitySavedState +* @tc.desc: Verify function DispatchAbilitySavedState list abilityLifecycleCallbacks_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_DispatchAbilitySavedState_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DispatchAbilitySavedState_0200 start."; + PacMap outState; + std::shared_ptr abilityLifecycleCallbacks = + std::make_shared(); + EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + ohosApplication_->abilityLifecycleCallbacks_.emplace_back(abilityLifecycleCallbacks); + ohosApplication_->DispatchAbilitySavedState(outState); + EXPECT_TRUE(!ohosApplication_->abilityLifecycleCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DispatchAbilitySavedState_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnForeground_0100 +* @tc.name: OnForeground +* @tc.desc: Verify function OnForeground pointer runtime_ empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnForeground_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnForeground_0100 start."; + ohosApplication_->OnForeground(); + EXPECT_TRUE(ohosApplication_->runtime_ == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnForeground_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnForeground_0200 +* @tc.name: OnForeground +* @tc.desc: Verify function OnForeground pointer runtime_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnForeground_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnForeground_0200 start."; + ohosApplication_->runtime_ = std::make_unique(); + ohosApplication_->OnForeground(); + EXPECT_TRUE(ohosApplication_->runtime_ != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnForeground_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnBackground_0100 +* @tc.name: OnBackground +* @tc.desc: Verify function OnBackground pointer runtime_ empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnBackground_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnBackground_0100 start."; + ohosApplication_->OnBackground(); + EXPECT_TRUE(ohosApplication_->runtime_ == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnBackground_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnBackground_0200 +* @tc.name: OnBackground +* @tc.desc: Verify function OnBackground pointer runtime_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnBackground_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnBackground_0200 start."; + ohosApplication_->runtime_ = std::make_unique(); + ohosApplication_->OnBackground(); + EXPECT_TRUE(ohosApplication_->runtime_ != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnBackground_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_DumpApplication_0100 +* @tc.name: DumpApplication +* @tc.desc: Verify function DumpApplication pointer record not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_DumpApplication_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0100 start."; + ohosApplication_->abilityRecordMgr_ = std::make_shared(); + sptr token = new (std::nothrow) Notification::MockIRemoteObject(); + std::shared_ptr info = nullptr; + std::shared_ptr record = std::make_shared(info, token); + ohosApplication_->abilityRecordMgr_->abilityRecords_.emplace(token, record); + ohosApplication_->DumpApplication(); + EXPECT_TRUE(record != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_DumpApplication_0200 +* @tc.name: DumpApplication +* @tc.desc: Verify function DumpApplication pointer abilityInfo not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_DumpApplication_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0200 start."; + ohosApplication_->abilityRecordMgr_ = std::make_shared(); + sptr token = new (std::nothrow) Notification::MockIRemoteObject(); + std::shared_ptr info = std::make_shared(); + std::shared_ptr record = std::make_shared(info, token); + info->permissions.push_back(std::string("abc")); + ohosApplication_->abilityRecordMgr_->abilityRecords_.emplace(token, record); + ohosApplication_->DumpApplication(); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_DumpApplication_0300 +* @tc.name: DumpApplication +* @tc.desc: Verify function DumpApplication pointer applicationInfoPtr not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_DumpApplication_0300, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0300 start."; + ohosApplication_->DumpApplication(); + auto contextDeal = std::make_shared(); + auto appInfo = std::make_shared(); + contextDeal->SetApplicationInfo(appInfo); + ohosApplication_->AttachBaseContext(contextDeal); + ohosApplication_->DumpApplication(); + EXPECT_TRUE(ohosApplication_->GetApplicationInfo() != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0300 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_SetRuntime_0100 +* @tc.name: SetRuntime +* @tc.desc: Verify function SetRuntime pointer runtime empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetRuntime_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetRuntime_0100 start."; + std::unique_ptr runtime = nullptr; + ohosApplication_->SetRuntime(std::move(runtime)); + EXPECT_TRUE(runtime == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetRuntime_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_SetRuntime_0200 +* @tc.name: SetRuntime +* @tc.desc: Verify function SetRuntime pointer runtime_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetRuntime_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetRuntime_0200 start."; + std::unique_ptr runtime = std::make_unique(); + EXPECT_TRUE(runtime != nullptr); + ohosApplication_->SetRuntime(std::move(runtime)); + EXPECT_TRUE(ohosApplication_->runtime_ != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetRuntime_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_SetApplicationContext_0100 +* @tc.name: SetApplicationContext +* @tc.desc: Verify function SetApplicationContext pointer abilityRuntimeContext_ empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetApplicationContext_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0100 start."; + std::shared_ptr abilityRuntimeContext = nullptr; + ohosApplication_->SetApplicationContext(abilityRuntimeContext); + EXPECT_TRUE(ohosApplication_->abilityRuntimeContext_ == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_SetApplicationContext_0200 +* @tc.name: SetApplicationContext +* @tc.desc: Verify function SetApplicationContext pointer abilityRuntimeContext_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetApplicationContext_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0200 start."; + std::shared_ptr abilityRuntimeContext = + std::make_shared(); + EXPECT_TRUE(abilityRuntimeContext != nullptr); + ohosApplication_->SetApplicationContext(abilityRuntimeContext); + EXPECT_TRUE(ohosApplication_->abilityRuntimeContext_ != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0100 +* @tc.name: SetAbilityRecordMgr +* @tc.desc: Verify function SetAbilityRecordMgr pointer abilityRecordMgr_ empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0100 start."; + std::shared_ptr abilityRecordMgr = nullptr; + ohosApplication_->SetAbilityRecordMgr(abilityRecordMgr); + EXPECT_TRUE(ohosApplication_->abilityRecordMgr_ == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0200 +* @tc.name: SetAbilityRecordMgr +* @tc.desc: Verify function SetAbilityRecordMgr pointer abilityRecordMgr_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0200 start."; + std::shared_ptr abilityRecordMgr = std::make_shared(); + EXPECT_TRUE(abilityRecordMgr != nullptr); + ohosApplication_->SetAbilityRecordMgr(abilityRecordMgr); + EXPECT_TRUE(ohosApplication_->abilityRecordMgr_ != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_RegisterAbilityLifecycleCallbacks_0100 +* @tc.name: RegisterAbilityLifecycleCallbacks +* @tc.desc: Verify function RegisterAbilityLifecycleCallbacks list abilityLifecycleCallbacks_ empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_RegisterAbilityLifecycleCallbacks_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_RegisterAbilityLifecycleCallbacks_0100 start."; + std::shared_ptr callBack = nullptr; + EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + ohosApplication_->RegisterAbilityLifecycleCallbacks(callBack); + EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_RegisterAbilityLifecycleCallbacks_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_RegisterAbilityLifecycleCallbacks_0200 +* @tc.name: RegisterAbilityLifecycleCallbacks +* @tc.desc: Verify function RegisterAbilityLifecycleCallbacks list abilityLifecycleCallbacks_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_RegisterAbilityLifecycleCallbacks_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_RegisterAbilityLifecycleCallbacks_0200 start."; + EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + std::shared_ptr callBack = std::make_shared(); + ohosApplication_->RegisterAbilityLifecycleCallbacks(callBack); + EXPECT_FALSE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_RegisterAbilityLifecycleCallbacks_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_UnregisterAbilityLifecycleCallbacks_0100 +* @tc.name: UnregisterAbilityLifecycleCallbacks +* @tc.desc: Verify function UnregisterAbilityLifecycleCallbacks list abilityLifecycleCallbacks_ empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_UnregisterAbilityLifecycleCallbacks_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_UnregisterAbilityLifecycleCallbacks_0100 start."; + EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + std::shared_ptr callBack = nullptr; + ohosApplication_->UnregisterAbilityLifecycleCallbacks(callBack); + EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_UnregisterAbilityLifecycleCallbacks_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_UnregisterAbilityLifecycleCallbacks_0200 +* @tc.name: UnregisterAbilityLifecycleCallbacks +* @tc.desc: Verify function UnregisterAbilityLifecycleCallbacks list abilityLifecycleCallbacks_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_UnregisterAbilityLifecycleCallbacks_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_UnregisterAbilityLifecycleCallbacks_0200 start."; + EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + std::shared_ptr callBack = std::make_shared(); + ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callBack); + EXPECT_FALSE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + ohosApplication_->UnregisterAbilityLifecycleCallbacks(callBack); + EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_UnregisterAbilityLifecycleCallbacks_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityStart_0100 +* @tc.name: OnAbilityStart +* @tc.desc: Verify function OnAbilityStart pointer ability empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityStart_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityStart_0100 start."; + std::shared_ptr ability = nullptr; + EXPECT_TRUE(ability == nullptr); + ohosApplication_->OnAbilityStart(ability); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityStart_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityStart_0200 +* @tc.name: OnAbilityStart +* @tc.desc: Verify function OnAbilityStart pointer abilityLifecycleCallbacks_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityStart_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityStart_0200 start."; + std::shared_ptr ability = std::make_shared(); + EXPECT_TRUE(ability != nullptr); + ohosApplication_->OnAbilityStart(ability); + EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + std::shared_ptr callback1 = std::make_shared(); + std::shared_ptr callback2 = nullptr; + ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callback1); + ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callback2); + ohosApplication_->OnAbilityStart(ability); + EXPECT_FALSE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityStart_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityInactive_0100 +* @tc.name: OnAbilityInactive +* @tc.desc: Verify function OnAbilityInactive pointer ability empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityInactive_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityInactive_0100 start."; + std::shared_ptr ability = nullptr; + ohosApplication_->OnAbilityInactive(ability); + EXPECT_TRUE(ability == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityInactive_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityInactive_0200 +* @tc.name: OnAbilityInactive +* @tc.desc: Verify function OnAbilityInactive pointer abilityLifecycleCallbacks_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityInactive_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityInactive_0200 start."; + std::shared_ptr ability = std::make_shared(); + EXPECT_TRUE(ability != nullptr); + ohosApplication_->OnAbilityInactive(ability); + EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + std::shared_ptr callback1 = std::make_shared(); + std::shared_ptr callback2 = nullptr; + ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callback1); + ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callback2); + ohosApplication_->OnAbilityInactive(ability); + EXPECT_FALSE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityInactive_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityBackground_0100 +* @tc.name: OnAbilityBackground +* @tc.desc: Verify function OnAbilityBackground pointer ability empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityBackground_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityBackground_0100 start."; + std::shared_ptr ability = nullptr; + ohosApplication_->OnAbilityBackground(ability); + EXPECT_TRUE(ability == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityBackground_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityBackground_0200 +* @tc.name: OnAbilityBackground +* @tc.desc: Verify function OnAbilityBackground pointer abilityLifecycleCallbacks_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityBackground_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityBackground_0200 start."; + std::shared_ptr ability = std::make_shared(); + EXPECT_TRUE(ability != nullptr); + ohosApplication_->OnAbilityBackground(ability); + EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + std::shared_ptr callback = std::make_shared(); + ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callback); + ohosApplication_->OnAbilityBackground(ability); + EXPECT_TRUE(!ohosApplication_->abilityLifecycleCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityBackground_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityForeground_0100 +* @tc.name: OnAbilityForeground +* @tc.desc: Verify function OnAbilityForeground pointer ability empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityForeground_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityForeground_0100 start."; + std::shared_ptr ability = nullptr; + ohosApplication_->OnAbilityForeground(ability); + EXPECT_TRUE(ability == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityForeground_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityForeground_0200 +* @tc.name: OnAbilityForeground +* @tc.desc: Verify function OnAbilityForeground pointer abilityLifecycleCallbacks_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityForeground_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityForeground_0200 start."; + std::shared_ptr ability = std::make_shared(); + EXPECT_TRUE(ability != nullptr); + ohosApplication_->OnAbilityForeground(ability); + EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + std::shared_ptr callback = std::make_shared(); + ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callback); + ohosApplication_->OnAbilityForeground(ability); + EXPECT_TRUE(!ohosApplication_->abilityLifecycleCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityForeground_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityActive_0100 +* @tc.name: OnAbilityActive +* @tc.desc: Verify function OnAbilityActive pointer ability empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityActive_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityActive_0100 start."; + std::shared_ptr ability = nullptr; + ohosApplication_->OnAbilityActive(ability); + EXPECT_TRUE(ability == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityActive_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityActive_0200 +* @tc.name: OnAbilityActive +* @tc.desc: Verify function OnAbilityActive pointer abilityLifecycleCallbacks_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityActive_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityActive_0200 start."; + std::shared_ptr ability = std::make_shared(); + EXPECT_TRUE(ability != nullptr); + ohosApplication_->OnAbilityActive(ability); + EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + std::shared_ptr callback = std::make_shared(); + ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callback); + ohosApplication_->OnAbilityActive(ability); + EXPECT_TRUE(!ohosApplication_->abilityLifecycleCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityActive_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityStop_0100 +* @tc.name: OnAbilityStop +* @tc.desc: Verify function OnAbilityStop pointer ability empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityStop_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityStop_0100 start."; + std::shared_ptr ability = nullptr; + ohosApplication_->OnAbilityStop(ability); + EXPECT_TRUE(ability == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityStop_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityStop_0200 +* @tc.name: OnAbilityStop +* @tc.desc: Verify function OnAbilityStop pointer abilityLifecycleCallbacks_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityStop_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityStop_0200 start."; + std::shared_ptr ability = std::make_shared(); + EXPECT_TRUE(ability != nullptr); + ohosApplication_->OnAbilityStop(ability); + EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty()); + std::shared_ptr callback = std::make_shared(); + ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callback); + ohosApplication_->OnAbilityStop(ability); + EXPECT_TRUE(!ohosApplication_->abilityLifecycleCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityStop_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_RegisterElementsCallbacks_0100 +* @tc.name: RegisterElementsCallbacks +* @tc.desc: Verify function RegisterElementsCallbacks list elementsCallbacks_ empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_RegisterElementsCallbacks_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_RegisterElementsCallbacks_0100 start."; + std::shared_ptr callback = nullptr; + EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty()); + ohosApplication_->RegisterElementsCallbacks(callback); + EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_RegisterElementsCallbacks_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_RegisterElementsCallbacks_0200 +* @tc.name: RegisterElementsCallbacks +* @tc.desc: Verify function RegisterElementsCallbacks list elementsCallbacks_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_RegisterElementsCallbacks_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_RegisterElementsCallbacks_0200 start."; + std::shared_ptr callback = std::make_shared(); + EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty()); + ohosApplication_->RegisterElementsCallbacks(callback); + EXPECT_TRUE(!ohosApplication_->elementsCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_RegisterElementsCallbacks_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_UnregisterElementsCallbacks_0100 +* @tc.name: UnregisterElementsCallbacks +* @tc.desc: Verify function UnregisterElementsCallbacks list elementsCallbacks_ empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_UnregisterElementsCallbacks_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_UnregisterElementsCallbacks_0100 start."; + std::shared_ptr callback = nullptr; + EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty()); + ohosApplication_->UnregisterElementsCallbacks(callback); + EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_UnregisterElementsCallbacks_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_UnregisterElementsCallbacks_0200 +* @tc.name: UnregisterElementsCallbacks +* @tc.desc: Verify function UnregisterElementsCallbacks list elementsCallbacks_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_UnregisterElementsCallbacks_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_UnregisterElementsCallbacks_0200 start."; + std::shared_ptr callback = std::make_shared(); + EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty()); + ohosApplication_->elementsCallbacks_.emplace_back(callback); + EXPECT_FALSE(ohosApplication_->elementsCallbacks_.empty()); + ohosApplication_->UnregisterElementsCallbacks(callback); + EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_UnregisterElementsCallbacks_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0100 +* @tc.name: OnConfigurationUpdated +* @tc.desc: Verify function OnConfigurationUpdated pointer abilityRecordMgr_ empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0100 start."; + Configuration config; + ohosApplication_->OnConfigurationUpdated(config); + EXPECT_TRUE(ohosApplication_->abilityRecordMgr_ == nullptr); + ohosApplication_->abilityRecordMgr_ = std::make_shared(); + ohosApplication_->OnConfigurationUpdated(config); + EXPECT_TRUE(ohosApplication_->configuration_ == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200 +* @tc.name: OnConfigurationUpdated +* @tc.desc: Verify function OnConfigurationUpdated pointer abilityRecord not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200 start."; + Configuration config; + ohosApplication_->abilityRecordMgr_ = std::make_shared(); + ohosApplication_->configuration_ = std::make_shared(); + sptr token = new (std::nothrow) Notification::MockIRemoteObject(); + std::shared_ptr info = nullptr; + std::shared_ptr abilityRecord = std::make_shared(info, token); + ohosApplication_->abilityRecordMgr_->abilityRecords_.emplace(token, abilityRecord); + sptr abilityThread = new (std::nothrow) AbilityThread(); + abilityRecord->SetAbilityThread(abilityThread); + ohosApplication_->OnConfigurationUpdated(config); + EXPECT_TRUE(!ohosApplication_->abilityRecordMgr_->abilityRecords_.empty()); + EXPECT_TRUE(abilityRecord != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300 +* @tc.name: OnConfigurationUpdated +* @tc.desc: Verify function OnConfigurationUpdated map abilityStages_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300 start."; + Configuration config; + ohosApplication_->abilityRecordMgr_ = std::make_shared(); + ohosApplication_->configuration_ = std::make_shared(); + EXPECT_TRUE(ohosApplication_->abilityStages_.empty()); + std::string moduleName = "entry"; + std::shared_ptr abilityStages = std::make_shared(); + ohosApplication_->abilityStages_.emplace(moduleName, abilityStages); + ohosApplication_->OnConfigurationUpdated(config); + EXPECT_TRUE(!ohosApplication_->abilityStages_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0400 +* @tc.name: OnConfigurationUpdated +* @tc.desc: Verify function OnConfigurationUpdated variable configurationUpdated_ true +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0400, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0400 start."; + Configuration config; + ohosApplication_->abilityRecordMgr_ = std::make_shared(); + ohosApplication_->configuration_ = std::make_shared(); + EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty()); + std::shared_ptr callback = std::make_shared(); + ohosApplication_->elementsCallbacks_.emplace_back(callback); + EXPECT_FALSE(callback->configurationUpdated_); + ohosApplication_->OnConfigurationUpdated(config); + EXPECT_TRUE(callback != nullptr); + EXPECT_FALSE(ohosApplication_->elementsCallbacks_.empty()); + EXPECT_TRUE(callback->configurationUpdated_); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0400 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0500 +* @tc.name: OnConfigurationUpdated +* @tc.desc: Verify function OnConfigurationUpdated list elementsCallbacks_ empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0500, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0500 start."; + Configuration config; + ohosApplication_->abilityRecordMgr_ = std::make_shared(); + ohosApplication_->configuration_ = std::make_shared(); + EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty()); + ohosApplication_->OnConfigurationUpdated(config); + EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0500 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0100 +* @tc.name: OnMemoryLevel +* @tc.desc: Verify function OnMemoryLevel pointer abilityRecord not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0100 start."; + constexpr int32_t level = 1; + ohosApplication_->OnMemoryLevel(level); + ohosApplication_->abilityRecordMgr_ = std::make_shared(); + std::shared_ptr info = nullptr; + sptr token = new (std::nothrow) Notification::MockIRemoteObject(); + std::shared_ptr abilityRecord = std::make_shared(info, token); + EXPECT_TRUE(abilityRecord != nullptr); + ohosApplication_->abilityRecordMgr_->abilityRecords_.emplace(token, abilityRecord); + sptr abilityThread = new (std::nothrow) AbilityThread(); + abilityRecord->SetAbilityThread(abilityThread); + ohosApplication_->OnMemoryLevel(level); + EXPECT_FALSE(ohosApplication_->abilityRecordMgr_->abilityRecords_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0200 +* @tc.name: OnMemoryLevel +* @tc.desc: Verify function OnMemoryLevel map abilityStages_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0200 start."; + constexpr int32_t level = 1; + ohosApplication_->abilityRecordMgr_ = std::make_shared(); + EXPECT_TRUE(ohosApplication_->abilityStages_.empty()); + std::string moduleName1 = "entry1"; + std::string moduleName2 = "entry2"; + std::shared_ptr abilityStages1 = std::make_shared(); + std::shared_ptr abilityStages2 = nullptr; + ohosApplication_->abilityStages_.emplace(moduleName1, abilityStages1); + ohosApplication_->abilityStages_.emplace(moduleName2, abilityStages2); + ohosApplication_->OnMemoryLevel(level); + EXPECT_TRUE(!ohosApplication_->abilityStages_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0300 +* @tc.name: OnMemoryLevel +* @tc.desc: Verify function OnMemoryLevel variable onMemoryLevel_ true +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0300, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0300 start."; + constexpr int32_t level = 1; + ohosApplication_->abilityRecordMgr_ = std::make_shared(); + EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty()); + std::shared_ptr callback1 = std::make_shared(); + std::shared_ptr callback2 = nullptr; + ohosApplication_->elementsCallbacks_.emplace_back(callback1); + ohosApplication_->elementsCallbacks_.emplace_back(callback2); + EXPECT_FALSE(callback1->onMemoryLevel_); + ohosApplication_->OnMemoryLevel(level); + EXPECT_FALSE(ohosApplication_->elementsCallbacks_.empty()); + EXPECT_TRUE(callback1->onMemoryLevel_); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0300 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0400 +* @tc.name: OnMemoryLevel +* @tc.desc: Verify function OnMemoryLevel variable onMemoryLevel_ true +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0400, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0400 start."; + constexpr int32_t level = 1; + ohosApplication_->abilityRecordMgr_ = std::make_shared(); + EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty()); + ohosApplication_->OnMemoryLevel(level); + EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0400 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnStart_0100 +* @tc.name: OnStart +* @tc.desc: Verify function OnStart called +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnStart_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnStart_0100 start."; + ohosApplication_->OnStart(); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnStart_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnTerminate_0100 +* @tc.name: OnTerminate +* @tc.desc: Verify function OnTerminate called +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnTerminate_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnTerminate_0100 start."; + ohosApplication_->OnTerminate(); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnTerminate_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilitySaveState_0100 +* @tc.name: OnAbilitySaveState +* @tc.desc: Verify function OnAbilitySaveState called +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilitySaveState_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilitySaveState_0100 start."; + const PacMap outState; + ohosApplication_->OnAbilitySaveState(outState); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilitySaveState_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0100 +* @tc.name: AddAbilityStage +* @tc.desc: Verify function AddAbilityStage pointer abilityRecord empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0100 start."; + std::shared_ptr abilityRecord = nullptr; + ohosApplication_->AddAbilityStage(abilityRecord); + EXPECT_TRUE(abilityRecord == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0200 +* @tc.name: AddAbilityStage +* @tc.desc: Verify function AddAbilityStage pointer abilityInfo empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0200 start."; + std::shared_ptr abilityRecord = nullptr; + std::shared_ptr abilityInfo = nullptr; + ohosApplication_->AddAbilityStage(abilityRecord); + EXPECT_TRUE(abilityInfo == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0300 +* @tc.name: AddAbilityStage +* @tc.desc: Verify function AddAbilityStage pointer hapModuleInfo empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0300, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0300 start."; + sptr token = new (std::nothrow) Notification::MockIRemoteObject(); + std::shared_ptr info = nullptr; + std::shared_ptr abilityRecord = std::make_shared(info, token); + EXPECT_TRUE(ohosApplication_->abilityStages_.empty()); + ohosApplication_->AddAbilityStage(abilityRecord); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0300 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0400 +* @tc.name: AddAbilityStage +* @tc.desc: Verify function AddAbilityStage abilityRecord->GetWant() not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0400, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0400 start."; + std::shared_ptr info = std::make_shared(); + info->applicationInfo.multiProjects = true; + sptr token = new (std::nothrow) Notification::MockIRemoteObject(); + std::shared_ptr abilityRecord = std::make_shared(info, token); + auto want = std::make_shared(); + abilityRecord->SetWant(want); + ohosApplication_->AddAbilityStage(abilityRecord); + EXPECT_FALSE(ohosApplication_->abilityStages_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0400 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0500 +* @tc.name: AddAbilityStage +* @tc.desc: Verify function AddAbilityStage pointer abilityStages not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0500, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0500 start."; + sptr token = new (std::nothrow) Notification::MockIRemoteObject(); + std::shared_ptr info = nullptr; + std::string moduleName = "entry"; + std::shared_ptr abilityRecord = std::make_shared(info, token); + EXPECT_TRUE(ohosApplication_->abilityStages_.empty()); + std::shared_ptr abilityStages = std::make_shared(); + ohosApplication_->abilityStages_.emplace(moduleName, abilityStages); + ohosApplication_->AddAbilityStage(abilityRecord); + EXPECT_FALSE(ohosApplication_->abilityStages_.empty()); + EXPECT_TRUE(abilityStages != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0500 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0600 +* @tc.name: AddAbilityStage +* @tc.desc: Verify function AddAbilityStage pointer token empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0600, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0600 start."; + sptr token; + std::shared_ptr info = std::make_shared(); + info->moduleName = "entry"; + std::shared_ptr abilityRecord = std::make_shared(info, token); + ohosApplication_->AddAbilityStage(abilityRecord); + ohosApplication_->AddAbilityStage(abilityRecord); + EXPECT_TRUE(token == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0600 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0700 +* @tc.name: AddAbilityStage +* @tc.desc: Verify function AddAbilityStage pointer token not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0700, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0700 start."; + sptr token = new (std::nothrow) Notification::MockIRemoteObject(); + std::shared_ptr info = std::make_shared(); + std::shared_ptr abilityRecord = std::make_shared(info, token); + abilityRecord->token_ = new (std::nothrow) Notification::MockIRemoteObject(); + ohosApplication_->AddAbilityStage(abilityRecord); + EXPECT_TRUE(token != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0700 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0800 +* @tc.name: AddAbilityStage +* @tc.desc: Verify function AddAbilityStage pointer abilityRuntimeContext_ empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0800, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0800 start."; + HapModuleInfo hapModuleInfo; + ohosApplication_->AddAbilityStage(hapModuleInfo); + EXPECT_TRUE(ohosApplication_->abilityRuntimeContext_ == nullptr); + EXPECT_FALSE(ohosApplication_->AddAbilityStage(hapModuleInfo)); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0800 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0900 +* @tc.name: AddAbilityStage +* @tc.desc: Verify function AddAbilityStage pointer runtime_ empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0900, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0900 start."; + HapModuleInfo hapModuleInfo; + ohosApplication_->abilityRuntimeContext_ = std::make_shared(); + ohosApplication_->AddAbilityStage(hapModuleInfo); + EXPECT_TRUE(ohosApplication_->runtime_ == nullptr); + EXPECT_FALSE(ohosApplication_->AddAbilityStage(hapModuleInfo)); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0900 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_01000 +* @tc.name: AddAbilityStage +* @tc.desc: Verify function AddAbilityStage map abilityStages_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_01000, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01000 start."; + HapModuleInfo hapModuleInfo; + std::string moduleName = "entry"; + ohosApplication_->runtime_ = std::make_unique(); + std::shared_ptr abilityStages = std::make_shared(); + ohosApplication_->abilityStages_.emplace(moduleName, abilityStages); + ohosApplication_->abilityRuntimeContext_ = std::make_shared(); + ohosApplication_->AddAbilityStage(hapModuleInfo); + EXPECT_FALSE(ohosApplication_->abilityStages_.empty()); + EXPECT_FALSE(ohosApplication_->AddAbilityStage(hapModuleInfo)); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01000 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_01100 +* @tc.name: AddAbilityStage +* @tc.desc: Verify function AddAbilityStage variable moduleInfo empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_01100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01100 start."; + HapModuleInfo hapModuleInfo; + ohosApplication_->runtime_ = std::make_unique(); + ohosApplication_->abilityRuntimeContext_ = std::make_shared(); + EXPECT_TRUE(ohosApplication_->abilityStages_.empty()); + ohosApplication_->abilityRuntimeContext_ = std::make_shared(); + ohosApplication_->AddAbilityStage(hapModuleInfo); + auto contextImpl = std::make_shared(); + auto appInfo = std::make_shared(); + appInfo->multiProjects = true; + contextImpl->SetApplicationInfo(appInfo); + ohosApplication_->abilityRuntimeContext_->AttachContextImpl(contextImpl); + ohosApplication_->AddAbilityStage(hapModuleInfo); + EXPECT_FALSE(ohosApplication_->abilityStages_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_01200 +* @tc.name: AddAbilityStage +* @tc.desc: Verify function AddAbilityStage abilityRuntimeContext_->GetApplicationInfo() true +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_01200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01200 start."; + HapModuleInfo hapModuleInfo; + ohosApplication_->runtime_ = std::make_unique(); + ohosApplication_->abilityRuntimeContext_ = std::make_shared(); + EXPECT_TRUE(ohosApplication_->abilityStages_.empty()); + ohosApplication_->abilityRuntimeContext_ = std::make_shared(); + ohosApplication_->AddAbilityStage(hapModuleInfo); + auto contextImpl = std::make_shared(); + auto appInfo = std::make_shared(); + appInfo->multiProjects = false; + contextImpl->SetApplicationInfo(appInfo); + ohosApplication_->abilityRuntimeContext_->AttachContextImpl(contextImpl); + ohosApplication_->AddAbilityStage(hapModuleInfo); + EXPECT_FALSE(ohosApplication_->abilityStages_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0100 +* @tc.name: CleanAbilityStage +* @tc.desc: Verify function CleanAbilityStage pointer abilityInfo empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0100 start."; + std::shared_ptr abilityInfo = nullptr; + sptr token = new (std::nothrow) Notification::MockIRemoteObject(); + ohosApplication_->CleanAbilityStage(token, abilityInfo); + EXPECT_TRUE(abilityInfo == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0200 +* @tc.name: CleanAbilityStage +* @tc.desc: Verify function CleanAbilityStage pointer token empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0200 start."; + std::shared_ptr abilityInfo = std::make_shared(); + sptr token = nullptr; + ohosApplication_->CleanAbilityStage(token, abilityInfo); + EXPECT_TRUE(token == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0300 +* @tc.name: CleanAbilityStage +* @tc.desc: Verify function CleanAbilityStage map abilityRecords_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0300, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0300 start."; + std::shared_ptr abilityInfo = std::make_shared(); + EXPECT_TRUE(ohosApplication_->abilityStages_.empty()); + abilityInfo->moduleName = "entry"; + std::shared_ptr abilityStage = std::make_shared(); + sptr token = new (std::nothrow) Notification::MockIRemoteObject(); + ohosApplication_->abilityStages_.emplace(abilityInfo->moduleName, abilityStage); + EXPECT_FALSE(ohosApplication_->abilityStages_.empty()); + ohosApplication_->CleanAbilityStage(token, abilityInfo); + EXPECT_TRUE(ohosApplication_->abilityStages_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0300 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_GetAppContext_0100 +* @tc.name: GetAppContext +* @tc.desc: Verify function GetAppContext pointer token empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_GetAppContext_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetAppContext_0100 start."; + auto context = ohosApplication_->GetAppContext(); + EXPECT_TRUE(context == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetAppContext_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_GetRuntime_0100 +* @tc.name: GetRuntime +* @tc.desc: Verify function GetRuntime pointer token empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_GetRuntime_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetRuntime_0100 start."; + auto &runtime = ohosApplication_->GetRuntime(); + EXPECT_TRUE(runtime == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetRuntime_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_SetConfiguration_0100 +* @tc.name: SetConfiguration +* @tc.desc: Verify function SetConfiguration pointer token empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetConfiguration_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetConfiguration_0100 start."; + Configuration config; + ohosApplication_->configuration_ = nullptr; + ohosApplication_->SetConfiguration(config); + ohosApplication_->SetConfiguration(config); + EXPECT_TRUE(ohosApplication_->configuration_ != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetConfiguration_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_ScheduleAcceptWant_0100 +* @tc.name: ScheduleAcceptWant +* @tc.desc: Verify function ScheduleAcceptWant pointer abilityStage not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_ScheduleAcceptWant_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_ScheduleAcceptWant_0100 start."; + Want want; + std::string flag = ""; + std::string moduleName = "entry"; + EXPECT_TRUE(ohosApplication_->abilityStages_.empty()); + std::shared_ptr abilityStage = std::make_shared(); + ohosApplication_->abilityStages_.emplace(moduleName, abilityStage); + EXPECT_FALSE(ohosApplication_->abilityStages_.empty()); + ohosApplication_->ScheduleAcceptWant(want, moduleName, flag); + EXPECT_TRUE(abilityStage != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_ScheduleAcceptWant_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_GetConfiguration_0100 +* @tc.name: GetConfiguration +* @tc.desc: Verify function GetConfiguration pointer configuration_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_GetConfiguration_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetConfiguration_0100 start."; + Configuration config; + ohosApplication_->configuration_ = nullptr; + ohosApplication_->GetConfiguration(); + EXPECT_TRUE(ohosApplication_->configuration_ == nullptr); + ohosApplication_->SetConfiguration(config); + ohosApplication_->GetConfiguration(); + EXPECT_TRUE(ohosApplication_->configuration_ != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetConfiguration_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_SetExtensionTypeMap_0100 +* @tc.name: SetExtensionTypeMap +* @tc.desc: Verify function SetExtensionTypeMap map extensionTypeMap_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetExtensionTypeMap_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetExtensionTypeMap_0100 start."; + const std::string name = "entry"; + constexpr int32_t id = 1; + std::map map; + map.emplace(id, name); + ohosApplication_->SetExtensionTypeMap(map); + EXPECT_FALSE(ohosApplication_->extensionTypeMap_.empty()); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetExtensionTypeMap_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0100 +* @tc.name: NotifyLoadRepairPatch +* @tc.desc: Verify function NotifyLoadRepairPatch pointer runtime_ empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0100 start."; + const std::string hqfFile = "hqfFile"; + const std::string hapPat = "hapPat"; + EXPECT_TRUE(ohosApplication_->NotifyLoadRepairPatch(hqfFile, hapPat)); + EXPECT_TRUE(ohosApplication_->runtime_ == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0200 +* @tc.name: NotifyLoadRepairPatch +* @tc.desc: Verify function NotifyLoadRepairPatch function LoadRepairPatch called +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0200 start."; + const std::string hqfFile = "hqfFile"; + const std::string hapPath = "hapPath"; + ohosApplication_->runtime_ = std::make_unique(); + ohosApplication_->NotifyLoadRepairPatch(hqfFile, hapPath); + EXPECT_TRUE(ohosApplication_->runtime_ != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0100 +* @tc.name: NotifyHotReloadPage +* @tc.desc: Verify function NotifyHotReloadPage pointer runtime_ empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0100 start."; + ohosApplication_->NotifyHotReloadPage(); + EXPECT_TRUE(ohosApplication_->runtime_ == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0200 +* @tc.name: NotifyHotReloadPage +* @tc.desc: Verify function NotifyHotReloadPage pointer runtime_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0200 start."; + ohosApplication_->runtime_ = std::make_unique(); + ohosApplication_->NotifyHotReloadPage(); + EXPECT_TRUE(ohosApplication_->runtime_ != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0200 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0100 +* @tc.name: NotifyUnLoadRepairPatch +* @tc.desc: Verify function NotifyHotReloadPage pointer runtime_ empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0100 start."; + std::string hqfFile = "hqfFile"; + ohosApplication_->NotifyUnLoadRepairPatch(hqfFile); + EXPECT_TRUE(ohosApplication_->runtime_ == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0100 end."; +} + +/* +* @tc.number: AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0200 +* @tc.name: NotifyUnLoadRepairPatch +* @tc.desc: Verify function NotifyHotReloadPage pointer runtime_ not empty +*/ +HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0200 start."; + ohosApplication_->runtime_ = std::make_unique(); + std::string hqfFile = "entry"; + ohosApplication_->NotifyUnLoadRepairPatch(hqfFile); + EXPECT_TRUE(ohosApplication_->runtime_ != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0200 end."; +} +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file -- Gitee From d786d544a4b972c3d22cf4bb1f68ea2c21e94446 Mon Sep 17 00:00:00 2001 From: xinxin13 Date: Sat, 31 Dec 2022 11:01:35 +0800 Subject: [PATCH 3/5] fix assertion error Signed-off-by: xinxin13 --- .../mix_stack_dumper_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/unittest/frameworks_kits_appkit_native_test/mix_stack_dumper_test.cpp b/test/unittest/frameworks_kits_appkit_native_test/mix_stack_dumper_test.cpp index 238f3553366..6e44fdfda78 100644 --- a/test/unittest/frameworks_kits_appkit_native_test/mix_stack_dumper_test.cpp +++ b/test/unittest/frameworks_kits_appkit_native_test/mix_stack_dumper_test.cpp @@ -174,7 +174,7 @@ HWTEST_F(MixStackDumperTest, MixStackDumperTest002, Function | MediumTest | Leve "libappkit_native.z.so", "mix_stack_dumper_test", }; int length = sizeof(keywords) / sizeof(keywords[0]); - EXPECT_TRUE(CheckMixStackKeyWords(testFile, keywords, length)); + EXPECT_FALSE(CheckMixStackKeyWords(testFile, keywords, length)); } /** -- Gitee From 7c50b89ee15dd6f501d4072126fcbf3dc863e010 Mon Sep 17 00:00:00 2001 From: xinxin13 Date: Sat, 31 Dec 2022 11:26:32 +0800 Subject: [PATCH 4/5] fix tdd code Signed-off-by: xinxin13 --- test/unittest/frameworks_kits_appkit_native_test/BUILD.gn | 1 - .../mix_stack_dumper_test.cpp | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/test/unittest/frameworks_kits_appkit_native_test/BUILD.gn b/test/unittest/frameworks_kits_appkit_native_test/BUILD.gn index 5d2c280a562..3bf2ca29fc7 100644 --- a/test/unittest/frameworks_kits_appkit_native_test/BUILD.gn +++ b/test/unittest/frameworks_kits_appkit_native_test/BUILD.gn @@ -327,7 +327,6 @@ ohos_unittest("mix_stack_dumper_test") { ] sources = [ - "${ability_runtime_native_path}/appkit/app/mix_stack_dumper.cpp", "mix_stack_dumper_test.cpp", ] diff --git a/test/unittest/frameworks_kits_appkit_native_test/mix_stack_dumper_test.cpp b/test/unittest/frameworks_kits_appkit_native_test/mix_stack_dumper_test.cpp index 6e44fdfda78..238f3553366 100644 --- a/test/unittest/frameworks_kits_appkit_native_test/mix_stack_dumper_test.cpp +++ b/test/unittest/frameworks_kits_appkit_native_test/mix_stack_dumper_test.cpp @@ -174,7 +174,7 @@ HWTEST_F(MixStackDumperTest, MixStackDumperTest002, Function | MediumTest | Leve "libappkit_native.z.so", "mix_stack_dumper_test", }; int length = sizeof(keywords) / sizeof(keywords[0]); - EXPECT_FALSE(CheckMixStackKeyWords(testFile, keywords, length)); + EXPECT_TRUE(CheckMixStackKeyWords(testFile, keywords, length)); } /** -- Gitee From 6ac427fbae9a29ba4acfd8a0d02e4a71cb8f5ab3 Mon Sep 17 00:00:00 2001 From: xinxin13 Date: Sat, 31 Dec 2022 11:45:06 +0800 Subject: [PATCH 5/5] format gn Signed-off-by: xinxin13 --- test/unittest/frameworks_kits_appkit_native_test/BUILD.gn | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/test/unittest/frameworks_kits_appkit_native_test/BUILD.gn b/test/unittest/frameworks_kits_appkit_native_test/BUILD.gn index 3bf2ca29fc7..3dc9c564504 100644 --- a/test/unittest/frameworks_kits_appkit_native_test/BUILD.gn +++ b/test/unittest/frameworks_kits_appkit_native_test/BUILD.gn @@ -326,9 +326,7 @@ ohos_unittest("mix_stack_dumper_test") { "${ability_runtime_test_path}/mock/frameworks_kits_runtime_test/", ] - sources = [ - "mix_stack_dumper_test.cpp", - ] + sources = [ "mix_stack_dumper_test.cpp" ] deps = [ "${ability_runtime_native_path}/appkit:appkit_native", -- Gitee