From 7e688247cfb638afe8a29e1cd3d3bfbe2f969673 Mon Sep 17 00:00:00 2001 From: xinking129 Date: Sat, 23 Dec 2023 13:45:42 +0800 Subject: [PATCH] AutoFill UT testcases Signed-off-by: xinking129 --- test/unittest/BUILD.gn | 1 + .../BUILD.gn | 64 ++++++ ...auto_fill_extension_module_loader_test.cpp | 100 ++++++++ .../auto_fill_extension_test.cpp | 215 ++++++++++++++++++ .../js_auto_fill_extension_test/BUILD.gn | 79 +++++++ .../js_auto_fill_extension_test.cpp | 177 ++++++++++++++ 6 files changed, 636 insertions(+) create mode 100644 test/unittest/frameworks_kits_ability_native_test/auto_fill_extension_module_loader_test.cpp create mode 100644 test/unittest/frameworks_kits_ability_native_test/auto_fill_extension_test.cpp create mode 100644 test/unittest/js_auto_fill_extension_test/BUILD.gn create mode 100644 test/unittest/js_auto_fill_extension_test/js_auto_fill_extension_test.cpp diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index d31f3f0441..1fa01206bf 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -427,6 +427,7 @@ group("unittest") { "free_install_manager_test:unittest", "image_info_test:unittest", "implicit_start_processor_test:unittest", + "js_auto_fill_extension_test:unittest", "js_service_extension_test:unittest", "lifecycle_deal_test:unittest", "lifecycle_test:unittest", diff --git a/test/unittest/frameworks_kits_ability_native_test/BUILD.gn b/test/unittest/frameworks_kits_ability_native_test/BUILD.gn index 430b747fbc..04673f833a 100644 --- a/test/unittest/frameworks_kits_ability_native_test/BUILD.gn +++ b/test/unittest/frameworks_kits_ability_native_test/BUILD.gn @@ -2418,6 +2418,68 @@ ohos_unittest("share_extension_test") { ] } +ohos_unittest("auto_fill_extension_module_loader_test") { + module_out_path = module_output_path + include_dirs = [ "${ability_runtime_path}/interfaces/kits/native/ability/native/auto_fill_extension_ability" ] + + sources = [ + "${ability_runtime_native_path}/ability/native/auto_fill_extension_ability/auto_fill_extension_module_loader.cpp", + "auto_fill_extension_module_loader_test.cpp", + ] + + configs = [ ":module_private_config" ] + + deps = [ + "${ability_runtime_innerkits_path}/runtime:runtime", + "${ability_runtime_native_path}/ability/native:abilitykit_native", + "${ability_runtime_native_path}/ability/native:auto_fill_extension", + "${ability_runtime_native_path}/appkit:app_context", + "${ability_runtime_native_path}/appkit:appkit_native", + "//third_party/googletest:gtest_main", + ] + + external_deps = [ + "bundle_framework:appexecfwk_base", + "c_utils:utils", + "hilog:libhilog", + "ipc:ipc_core", + "napi:ace_napi", + ] +} + +ohos_unittest("auto_fill_extension_test") { + module_out_path = module_output_path + include_dirs = [ + "${ability_runtime_test_path}/mock/frameworks_kits_ability_native_test/include", + "${ability_runtime_path}/interfaces/kits/native/ability/native/auto_fill_extension_ability", + ] + + sources = [ "auto_fill_extension_test.cpp" ] + + configs = [ ":module_private_config" ] + + deps = [ + "${ability_runtime_innerkits_path}/ability_manager:ability_manager", + "${ability_runtime_innerkits_path}/runtime:runtime", + "${ability_runtime_native_path}/ability/native:abilitykit_native", + "${ability_runtime_native_path}/ability/native:auto_fill_extension", + "${ability_runtime_native_path}/appkit:app_context", + "${ability_runtime_native_path}/appkit:appkit_native", + "//third_party/googletest:gtest_main", + ] + + external_deps = [ + "ability_base:base", + "ability_base:want", + "bundle_framework:appexecfwk_base", + "c_utils:utils", + "eventhandler:libeventhandler", + "hilog:libhilog", + "ipc:ipc_core", + "napi:ace_napi", + ] +} + ############################################################################### group("unittest") { @@ -2445,6 +2507,8 @@ group("unittest") { ":abilityruntime_test", ":action_extension_module_loader_test", ":action_extension_test", + ":auto_fill_extension_module_loader_test", + ":auto_fill_extension_test", ":continuation_test", ":data_ability_helper_impl_test", ":data_ability_helper_test", diff --git a/test/unittest/frameworks_kits_ability_native_test/auto_fill_extension_module_loader_test.cpp b/test/unittest/frameworks_kits_ability_native_test/auto_fill_extension_module_loader_test.cpp new file mode 100644 index 0000000000..2a5cc1f406 --- /dev/null +++ b/test/unittest/frameworks_kits_ability_native_test/auto_fill_extension_module_loader_test.cpp @@ -0,0 +1,100 @@ +/* + * Copyright (c) 2023 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 "auto_fill_extension_module_loader.h" + +namespace OHOS { +namespace AbilityRuntime { +using namespace testing::ext; + +class AutoFillExtensionModuleLoaderTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void AutoFillExtensionModuleLoaderTest::SetUpTestCase(void) +{} + +void AutoFillExtensionModuleLoaderTest::TearDownTestCase(void) +{} + +void AutoFillExtensionModuleLoaderTest::SetUp(void) +{} + +void AutoFillExtensionModuleLoaderTest::TearDown(void) +{} + +/** + * @tc.name: GetExtensionModule_0100 + * @tc.desc: Verify can load AutoFillExtensionModule successfully. + * @tc.type: FUNC. + */ +HWTEST_F(AutoFillExtensionModuleLoaderTest, GetExtensionModule_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "GetExtensionModule_0100 start"; + void* handle = dlopen("/system/lib/extensionability/libauto_fill_extension_module.z.so", RTLD_LAZY); + if (handle != nullptr) { + auto obj = reinterpret_cast( + dlsym(handle, "OHOS_EXTENSION_GetExtensionModule")); + EXPECT_TRUE(obj != nullptr); + } + dlclose(handle); + GTEST_LOG_(INFO) << "GetExtensionModule_0100 end"; +} + +/** + * @tc.name: Create_0100 + * @tc.desc: Verify can create AutoFillExtensionModule successfully. + * @tc.type: FUNC + */ +HWTEST_F(AutoFillExtensionModuleLoaderTest, Create_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "Create_0100 start"; + std::unique_ptr runtime; + auto extension = AutoFillExtensionModuleLoader::GetInstance().Create(runtime); + EXPECT_TRUE(extension != nullptr); + GTEST_LOG_(INFO) << "Create_0100 end"; +} + +/** + * @tc.name: GetParams_0100 + * @tc.desc: Verify can get params successfully. + * @tc.type: FUNC + */ +HWTEST_F(AutoFillExtensionModuleLoaderTest, GetParams_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "GetParams_0100 start"; + auto params = AutoFillExtensionModuleLoader::GetInstance().GetParams(); + + std::string key = "type"; + auto finder = params.find(key); + if (finder != params.end()) { + EXPECT_STREQ(finder->second.c_str(), "501"); + } + + key = "name"; + auto iter = params.find(key); + if (iter != params.end()) { + EXPECT_STREQ(iter->second.c_str(), "AutoFillExtensionAbility"); + } + GTEST_LOG_(INFO) << "GetParams_0100 end"; +} +} // namespace AbilityRuntime +} // namespace OHOS diff --git a/test/unittest/frameworks_kits_ability_native_test/auto_fill_extension_test.cpp b/test/unittest/frameworks_kits_ability_native_test/auto_fill_extension_test.cpp new file mode 100644 index 0000000000..c0ea4c7bfe --- /dev/null +++ b/test/unittest/frameworks_kits_ability_native_test/auto_fill_extension_test.cpp @@ -0,0 +1,215 @@ +/* + * Copyright (c) 2023 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_handler.h" +#define private public +#include "context_impl.h" +#include "auto_fill_extension.h" +#include "auto_fill_extension_context.h" +#undef private +#include "mock_ability_token.h" +#include "ohos_application.h" +#include "runtime.h" + +namespace OHOS { +namespace AbilityRuntime { +using namespace testing::ext; +namespace { + const std::string BUNDLE_NAME = "com.ohos.settingsdata"; + const std::string MODULE_NAME = "entry"; +} +class AutoFillExtensionTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void AutoFillExtensionTest::SetUpTestCase(void) +{} + +void AutoFillExtensionTest::TearDownTestCase(void) +{} + +void AutoFillExtensionTest::SetUp(void) +{} + +void AutoFillExtensionTest::TearDown(void) +{} + +/** + * @tc.name: Create_0100 + * @tc.desc: The runtime is nullptr, and the verification of create is successful. + * @tc.type: FUNC + */ +HWTEST_F(AutoFillExtensionTest, Create_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "Create_0100 start"; + std::unique_ptr runtime; + auto autoFillExtension = AutoFillExtension::Create(runtime); + EXPECT_TRUE(autoFillExtension != nullptr); + GTEST_LOG_(INFO) << "Create_0100 end"; +} + +/** + * @tc.name: Create_0200 + * @tc.desc: The language is js, and the verification of create is successful. + * @tc.type: FUNC + */ +HWTEST_F(AutoFillExtensionTest, Create_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "Create_0200 start"; + Runtime::Options options; + auto runtime = Runtime::Create(options); + auto autoFillExtension = AutoFillExtension::Create(runtime); + EXPECT_TRUE(autoFillExtension != nullptr); + GTEST_LOG_(INFO) << "Create_0200 end"; +} + +/** + * @tc.name: Init_0100 + * @tc.desc: Verify the initialization is successful. + * @tc.type: FUNC + */ +HWTEST_F(AutoFillExtensionTest, Init_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "Init_0100 start"; + + Runtime::Options options; + std::unique_ptr runtime = Runtime::Create(options); + auto autoFillExtension = AutoFillExtension::Create(runtime); + EXPECT_NE(autoFillExtension, nullptr); + + auto abilityInfo = std::make_shared(); + sptr token = new AppExecFwk::MockAbilityToken(); + EXPECT_NE(token, nullptr); + auto record = std::make_shared(abilityInfo, token); + EXPECT_NE(record, nullptr); + auto application = std::make_shared(); + EXPECT_NE(application, nullptr); + auto contextImpl = std::make_shared(); + auto applicationContext = ApplicationContext::GetInstance(); + applicationContext->AttachContextImpl(contextImpl); + application->SetApplicationContext(applicationContext); + auto handler = std::make_shared(nullptr); + EXPECT_NE(handler, nullptr); + + autoFillExtension->Init(record, application, handler, token); + EXPECT_TRUE(autoFillExtension->context_ != nullptr); + GTEST_LOG_(INFO) << "Init_0100 end"; +} + +/** + * @tc.name: CreateAndInitContext_0100 + * @tc.desc: Verify that CreateAndInitContext function calls normally. + * @tc.type: FUNC + */ +HWTEST_F(AutoFillExtensionTest, CreateAndInitContext_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "CreateAndInitContext_0100 start"; + + Runtime::Options options; + std::unique_ptr runtime = Runtime::Create(options); + auto autoFillExtension = AutoFillExtension::Create(runtime); + EXPECT_NE(autoFillExtension, nullptr); + + auto abilityInfo = std::make_shared(); + EXPECT_NE(abilityInfo, nullptr); + abilityInfo->applicationInfo.multiProjects = true; + abilityInfo->moduleName = MODULE_NAME; + abilityInfo->bundleName = BUNDLE_NAME; + sptr token = new AppExecFwk::MockAbilityToken(); + EXPECT_NE(token, nullptr); + auto record = std::make_shared(abilityInfo, token); + EXPECT_NE(record, nullptr); + auto application = std::make_shared(); + EXPECT_NE(application, nullptr); + auto contextImpl = std::make_shared(); + auto applicationContext = ApplicationContext::GetInstance(); + applicationContext->AttachContextImpl(contextImpl); + application->SetApplicationContext(applicationContext); + auto handler = std::make_shared(nullptr); + EXPECT_NE(handler, nullptr); + + auto context = autoFillExtension->CreateAndInitContext(record, application, handler, token); + EXPECT_NE(context, nullptr); + + EXPECT_EQ(context->GetToken(), token); + auto appContext = Context::GetApplicationContext(); + auto appInfo = appContext->GetApplicationInfo(); + EXPECT_EQ(context->GetApplicationInfo(), appInfo); + + auto resourceManager = appContext->GetResourceManager(); + EXPECT_EQ(context->GetResourceManager(), resourceManager); + EXPECT_EQ(context->parentContext_, appContext); + + EXPECT_EQ(context->GetAbilityInfo(), abilityInfo); + EXPECT_EQ(context->GetConfiguration(), appContext->GetConfiguration()); + + GTEST_LOG_(INFO) << "CreateAndInitContext_0100 end"; +} + +/** + * @tc.name: CreateAndInitContext_0200 + * @tc.desc: Check nullptr AbilityLocalRecord. + * @tc.type: FUNC + */ +HWTEST_F(AutoFillExtensionTest, CreateAndInitContext_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "CreateAndInitContext_0200 start"; + + Runtime::Options options; + std::unique_ptr runtime = Runtime::Create(options); + auto autoFillExtension = AutoFillExtension::Create(runtime); + EXPECT_NE(autoFillExtension, nullptr); + + auto abilityInfo = std::make_shared(); + EXPECT_NE(abilityInfo, nullptr); + abilityInfo->moduleName = MODULE_NAME; + abilityInfo->bundleName = BUNDLE_NAME; + sptr token = new AppExecFwk::MockAbilityToken(); + EXPECT_NE(token, nullptr); + auto application = std::make_shared(); + EXPECT_NE(application, nullptr); + auto contextImpl = std::make_shared(); + auto applicationContext = ApplicationContext::GetInstance(); + applicationContext->AttachContextImpl(contextImpl); + application->SetApplicationContext(applicationContext); + auto handler = std::make_shared(nullptr); + EXPECT_NE(handler, nullptr); + std::shared_ptr record = nullptr; + + auto context = autoFillExtension->CreateAndInitContext(record, application, handler, token); + EXPECT_NE(context, nullptr); + + EXPECT_EQ(context->GetToken(), token); + auto appContext = Context::GetApplicationContext(); + auto appInfo = appContext->GetApplicationInfo(); + EXPECT_EQ(context->GetApplicationInfo(), appInfo); + + auto resourceManager = appContext->GetResourceManager(); + EXPECT_EQ(context->GetResourceManager(), resourceManager); + EXPECT_EQ(context->parentContext_, appContext); + + EXPECT_EQ(context->GetAbilityInfo(), nullptr); + EXPECT_EQ(context->GetConfiguration(), nullptr); + + GTEST_LOG_(INFO) << "CreateAndInitContext_0200 end"; +} +} // namespace AbilityRuntime +} // namespace OHOS \ No newline at end of file diff --git a/test/unittest/js_auto_fill_extension_test/BUILD.gn b/test/unittest/js_auto_fill_extension_test/BUILD.gn new file mode 100644 index 0000000000..08325c021c --- /dev/null +++ b/test/unittest/js_auto_fill_extension_test/BUILD.gn @@ -0,0 +1,79 @@ +# Copyright (c) 2023 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/ability/ability_runtime/ability_runtime.gni") + +module_output_path = "ability_runtime/auto_fill_extension" + +ohos_unittest("js_auto_fill_extension_test") { + module_out_path = module_output_path + include_dirs = [] + include_dirs = [ + "${ability_runtime_innerkits_path}/app_manager/include/appmgr", + "${ability_runtime_native_path}/runtime", + "${ability_runtime_native_path}/runtime/utils/include", + "${ability_runtime_path}/interfaces/kits/native/ability/ability_runtime", + "${ability_runtime_path}/interfaces/kits/native/ability/native/auto_fill_extension_ability", + "${ability_runtime_path}/interfaces/kits/native/appkit/app", + "${ability_runtime_test_path}/mock/frameworks_kits_ability_native_test/include", + "//third_party/jsoncpp/include", + "//third_party/json/include", + ] + + sources = [ "js_auto_fill_extension_test.cpp" ] + + configs = [ "${ability_runtime_services_path}/abilitymgr:abilityms_config" ] + deps = [ + "${ability_runtime_native_path}/ability/native:abilitykit_native", + "${ability_runtime_native_path}/ability/native:auto_fill_extension", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//third_party/icu/icu4c:shared_icuuc", + ] + + external_deps = [ + "ability_base:base", + "ability_base:configuration", + "ability_base:view_data", + "ability_base:want", + "ability_runtime:ability_manager", + "ability_runtime:app_context", + "ability_runtime:appkit_native", + "ability_runtime:extensionkit_native", + "ability_runtime:runtime", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "ets_runtime:libark_jsruntime", + "eventhandler:libeventhandler", + "hilog:libhilog", + "ipc:ipc_core", + "napi:ace_napi", + "resource_management:global_resmgr", + ] + + if (ability_runtime_graphics) { + external_deps += [ + "image_framework:image", + "window_manager:libdm", + "window_manager:libwm", + ] + } +} + +group("unittest") { + testonly = true + + deps = [ ":js_auto_fill_extension_test" ] +} diff --git a/test/unittest/js_auto_fill_extension_test/js_auto_fill_extension_test.cpp b/test/unittest/js_auto_fill_extension_test/js_auto_fill_extension_test.cpp new file mode 100644 index 0000000000..d499aaa53c --- /dev/null +++ b/test/unittest/js_auto_fill_extension_test/js_auto_fill_extension_test.cpp @@ -0,0 +1,177 @@ +/* + * Copyright (c) 2023 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 "ability_handler.h" +#include "ability_local_record.h" +#include "auto_fill_extension_context.h" +#include "configuration_convertor.h" +#define private public +#define protected public +#include "configuration_utils.h" +#undef private +#undef protected +#include "hilog_wrapper.h" +#include "iremote_object.h" +#define private public +#define protected public +#include "js_auto_fill_extension.h" +#include "js_auto_fill_extension_context.h" +#undef private +#undef protected +#include "js_runtime.h" +#include "mock_ability_token.h" +#include "ohos_application.h" +#include "runtime.h" +#include "string_wrapper.h" +#include "want.h" +#ifdef SUPPORT_GRAPHICS +#include "locale_config.h" +#include "window_scene.h" +#endif + +using namespace testing; +using namespace testing::ext; +using namespace testing::mt; + +namespace OHOS { +namespace AbilityRuntime { +namespace { +constexpr char JS_AUTO_FILL_EXTENSION_TASK_RUNNER[] = "JsAutoFillExtension"; +constexpr char DEFAULT_LANGUAGE[] = "zh_CN"; +} // namespace + +class JsAutoFillExtensionTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp() override; + void TearDown() override; + + std::shared_ptr jsAutoFillExtension_ = nullptr; + std::shared_ptr applicationContext_ = nullptr; + std::unique_ptr jsRuntime_ = nullptr; + +private: + void CreateJsAutoFillExtension(); +}; + +void JsAutoFillExtensionTest::SetUpTestCase() +{} + +void JsAutoFillExtensionTest::TearDownTestCase() +{} + +void JsAutoFillExtensionTest::SetUp() +{ + CreateJsAutoFillExtension(); +} + +void JsAutoFillExtensionTest::TearDown() +{} + +void JsAutoFillExtensionTest::CreateJsAutoFillExtension() +{ + std::shared_ptr abilityInfo = std::make_shared(); + sptr token(new (std::nothrow) MockAbilityToken()); + std::shared_ptr record = std::make_shared(abilityInfo, token); + + std::shared_ptr application = std::make_shared(); + std::shared_ptr contextImpl = std::make_shared(); + + Configuration config; + config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, DEFAULT_LANGUAGE); + config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE, ConfigurationInner::COLOR_MODE_LIGHT); + contextImpl->SetConfiguration(std::make_shared(config)); + + std::shared_ptr resourceManager(Global::Resource::CreateResourceManager()); + std::unique_ptr resConfig(Global::Resource::CreateResConfig()); +#ifdef SUPPORT_GRAPHICS + UErrorCode status = U_ZERO_ERROR; + icu::Locale locale = icu::Locale::forLanguageTag("zh", status); + HILOG_INFO("language: %{public}s, script: %{public}s, region: %{public}s", locale.getLanguage(), + locale.getScript(), locale.getCountry()); + resConfig->SetLocaleInfo(locale); +#endif + Global::Resource::RState updateRet = resourceManager->UpdateResConfig(*resConfig); + if (updateRet != Global::Resource::RState::SUCCESS) { + HILOG_ERROR("Init locale failed."); + } + contextImpl->SetResourceManager(resourceManager); + + std::shared_ptr applicationContext = + AbilityRuntime::ApplicationContext::GetInstance(); + applicationContext->AttachContextImpl(contextImpl); + application->SetApplicationContext(applicationContext); + applicationContext_ = applicationContext; + + std::shared_ptr handler = std::make_shared(nullptr); + + auto eventRunner = AppExecFwk::EventRunner::Create(JS_AUTO_FILL_EXTENSION_TASK_RUNNER); + Runtime::Options options; + options.preload = true; + options.eventRunner = eventRunner; + jsRuntime_ = JsRuntime::Create(options); + ASSERT_NE(jsRuntime_, nullptr); + + JsAutoFillExtension *extension = JsAutoFillExtension::Create(jsRuntime_); + ASSERT_NE(extension, nullptr); + jsAutoFillExtension_.reset(extension); + + jsAutoFillExtension_->Init(record, application, handler, token); +} + +/** + * @tc.name: Configuration_0100 + * @tc.desc: Js auto fill extension init. + * @tc.type: FUNC + */ +HWTEST_F(JsAutoFillExtensionTest, Init_0100, TestSize.Level1) +{ + ASSERT_NE(jsAutoFillExtension_, nullptr); + ASSERT_NE(applicationContext_, nullptr); + + auto context = jsAutoFillExtension_->GetContext(); + ASSERT_NE(context, nullptr); + auto configuration = context->GetConfiguration(); + EXPECT_NE(configuration, nullptr); + auto appConfig = applicationContext_->GetConfiguration(); + EXPECT_NE(appConfig, nullptr); +} + +/** + * @tc.name: OnStart_0100 + * @tc.desc: Js auto fill extension OnStart. + * @tc.type: FUNC + */ +HWTEST_F(JsAutoFillExtensionTest, OnStart_0100, TestSize.Level1) +{ + Want want; + ASSERT_NE(jsAutoFillExtension_, nullptr); + jsAutoFillExtension_->OnStart(want); + + auto context = jsAutoFillExtension_->GetContext(); + ASSERT_NE(context, nullptr); + auto configuration = context->GetConfiguration(); + EXPECT_NE(configuration, nullptr); + auto resourceManager = context->GetResourceManager(); + EXPECT_NE(resourceManager, nullptr); + auto appConfig = applicationContext_->GetConfiguration(); + EXPECT_NE(appConfig, nullptr); +} +} // namespace AbilityRuntime +} // namespace OHOS