From 9a60f0baf4596238cb66db00b20316204625b82f Mon Sep 17 00:00:00 2001 From: "zhaoyuan17@huawei.com" Date: Fri, 8 Oct 2021 20:04:04 +0800 Subject: [PATCH 01/10] fms st Signed-off-by: zhaoyuan17@huawei.com --- test/resource/formsystemtestability/BUILD.gn | 10 +- .../fmsSystemPerformance/BUILD.gn | 70 + .../fmsSystemPerformance/config.json | 80 + .../include/form_ability_performance.h | 101 ++ .../src/form_ability_performance.cpp | 372 +++++ .../fmsSystemStress/BUILD.gn | 70 + .../fmsSystemStress/config.json | 80 + .../include/form_ability_stress.h | 120 ++ .../src/form_ability_stress.cpp | 659 +++++++++ .../fmsSystemTestHostCommonA/BUILD.gn | 70 + .../fmsSystemTestHostCommonA/config.json | 80 + .../include/form_ability_commona.h | 82 ++ .../src/form_ability_commona.cpp | 188 +++ .../fmsSystemTestHostNoPerm/BUILD.gn | 70 + .../fmsSystemTestHostNoPerm/config.json | 60 + .../include/form_ability_no_perm.h | 82 ++ .../src/form_ability_no_perm.cpp | 186 +++ .../fmsSystemTestHostNormal/BUILD.gn | 72 + .../fmsSystemTestHostNormal/config.json | 122 ++ .../include/form_ability_a.h | 115 ++ .../include/form_ability_deleteform.h | 107 ++ .../include/form_ability_releaseform.h | 103 ++ .../src/form_ability_a.cpp | 644 ++++++++ .../src/form_ability_deleteform.cpp | 540 +++++++ .../src/form_ability_releaseform.cpp | 641 ++++++++ .../fmsSystemTestHostNormalB/BUILD.gn | 70 + .../fmsSystemTestHostNormalB/config.json | 80 + .../include/form_ability_b.h | 104 ++ .../src/form_ability_b.cpp | 311 ++++ .../fmsSystemTestHostNotSys/BUILD.gn | 70 + .../fmsSystemTestHostNotSys/config.json | 80 + .../include/form_ability_not_sys.h | 82 ++ .../src/form_ability_not_sys.cpp | 183 +++ .../tool/include/form_test_utils.h | 41 + .../tool/src/form_test_utils.cpp | 57 + test/systemtest/BUILD.gn | 1 + test/systemtest/common/fms/BUILD.gn | 42 + .../common/fms/common/include/form_event.h | 47 + .../fms/common/include/form_st_common_info.h | 248 ++++ .../fms/common/include/form_st_dump_util.h | 102 ++ .../fms/common/include/form_st_operator.h | 60 + .../common/fms/common/include/form_st_util.h | 365 +++++ .../common/fms/common/src/form_event.cpp | 124 ++ .../fms/common/src/form_st_dump_util.cpp | 161 ++ .../fms/common/src/form_st_operator.cpp | 125 ++ .../common/fms/common/src/form_st_util.cpp | 690 +++++++++ .../common/fms/fms_acquire_form_test/BUILD.gn | 75 + .../fms_acquire_form_test.cpp | 1305 +++++++++++++++++ .../common/fms/fms_delete_form_test/BUILD.gn | 75 + .../fms_delete_form_test.cpp | 803 ++++++++++ .../common/fms/fms_fuzz_test/BUILD.gn | 73 + .../fms_fuzz_test_config/config.json | 29 + .../include/fuzz_test_config_parser.h | 79 + .../fms_fuzz_test/include/fuzz_test_manager.h | 58 + .../fms/fms_fuzz_test/include/get_param.h | 394 +++++ .../fms/fms_fuzz_test/src/fms_fuzz_test.cpp | 74 + .../fms_fuzz_test/src/fuzz_test_manager.cpp | 215 +++ .../fms/fms_fuzz_test/src/get_param.cpp | 477 ++++++ .../test_lib/formManagerFuzzTest | Bin 0 -> 246288 bytes .../common/fms/fms_performance_test/BUILD.gn | 75 + .../fms_performance_config.json | 3 + .../fms_performance_test.cpp | 965 ++++++++++++ .../performance_config_parser.h | 59 + .../common/fms/fms_release_form_test/BUILD.gn | 75 + .../fms_release_form_test.cpp | 861 +++++++++++ .../common/fms/fms_stress_test/BUILD.gn | 75 + .../fms/fms_stress_test/fms_stress_test.cpp | 720 +++++++++ .../fms_stress_test_config.json | 3 + .../stress_test_config_parser.h | 59 + 69 files changed, 14318 insertions(+), 1 deletion(-) create mode 100755 test/resource/formsystemtestability/fmsSystemPerformance/BUILD.gn create mode 100644 test/resource/formsystemtestability/fmsSystemPerformance/config.json create mode 100644 test/resource/formsystemtestability/fmsSystemPerformance/include/form_ability_performance.h create mode 100644 test/resource/formsystemtestability/fmsSystemPerformance/src/form_ability_performance.cpp create mode 100755 test/resource/formsystemtestability/fmsSystemStress/BUILD.gn create mode 100644 test/resource/formsystemtestability/fmsSystemStress/config.json create mode 100644 test/resource/formsystemtestability/fmsSystemStress/include/form_ability_stress.h create mode 100644 test/resource/formsystemtestability/fmsSystemStress/src/form_ability_stress.cpp create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostCommonA/BUILD.gn create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostCommonA/config.json create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostCommonA/include/form_ability_commona.h create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostCommonA/src/form_ability_commona.cpp create mode 100755 test/resource/formsystemtestability/fmsSystemTestHostNoPerm/BUILD.gn create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostNoPerm/config.json create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostNoPerm/include/form_ability_no_perm.h create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostNoPerm/src/form_ability_no_perm.cpp create mode 100755 test/resource/formsystemtestability/fmsSystemTestHostNormal/BUILD.gn create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostNormal/config.json create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostNormal/include/form_ability_a.h create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostNormal/include/form_ability_deleteform.h create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostNormal/include/form_ability_releaseform.h create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostNormal/src/form_ability_a.cpp create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostNormal/src/form_ability_deleteform.cpp create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostNormal/src/form_ability_releaseform.cpp create mode 100755 test/resource/formsystemtestability/fmsSystemTestHostNormalB/BUILD.gn create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostNormalB/config.json create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostNormalB/include/form_ability_b.h create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostNormalB/src/form_ability_b.cpp create mode 100755 test/resource/formsystemtestability/fmsSystemTestHostNotSys/BUILD.gn create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostNotSys/config.json create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostNotSys/include/form_ability_not_sys.h create mode 100644 test/resource/formsystemtestability/fmsSystemTestHostNotSys/src/form_ability_not_sys.cpp create mode 100644 test/resource/formsystemtestability/tool/include/form_test_utils.h create mode 100644 test/resource/formsystemtestability/tool/src/form_test_utils.cpp create mode 100755 test/systemtest/common/fms/BUILD.gn create mode 100644 test/systemtest/common/fms/common/include/form_event.h create mode 100644 test/systemtest/common/fms/common/include/form_st_common_info.h create mode 100644 test/systemtest/common/fms/common/include/form_st_dump_util.h create mode 100644 test/systemtest/common/fms/common/include/form_st_operator.h create mode 100644 test/systemtest/common/fms/common/include/form_st_util.h create mode 100644 test/systemtest/common/fms/common/src/form_event.cpp create mode 100644 test/systemtest/common/fms/common/src/form_st_dump_util.cpp create mode 100644 test/systemtest/common/fms/common/src/form_st_operator.cpp create mode 100644 test/systemtest/common/fms/common/src/form_st_util.cpp create mode 100644 test/systemtest/common/fms/fms_acquire_form_test/BUILD.gn create mode 100644 test/systemtest/common/fms/fms_acquire_form_test/fms_acquire_form_test.cpp create mode 100644 test/systemtest/common/fms/fms_delete_form_test/BUILD.gn create mode 100644 test/systemtest/common/fms/fms_delete_form_test/fms_delete_form_test.cpp create mode 100644 test/systemtest/common/fms/fms_fuzz_test/BUILD.gn create mode 100644 test/systemtest/common/fms/fms_fuzz_test/fms_fuzz_test_config/config.json create mode 100644 test/systemtest/common/fms/fms_fuzz_test/include/fuzz_test_config_parser.h create mode 100644 test/systemtest/common/fms/fms_fuzz_test/include/fuzz_test_manager.h create mode 100644 test/systemtest/common/fms/fms_fuzz_test/include/get_param.h create mode 100644 test/systemtest/common/fms/fms_fuzz_test/src/fms_fuzz_test.cpp create mode 100644 test/systemtest/common/fms/fms_fuzz_test/src/fuzz_test_manager.cpp create mode 100644 test/systemtest/common/fms/fms_fuzz_test/src/get_param.cpp create mode 100644 test/systemtest/common/fms/fms_fuzz_test/test_lib/formManagerFuzzTest create mode 100644 test/systemtest/common/fms/fms_performance_test/BUILD.gn create mode 100644 test/systemtest/common/fms/fms_performance_test/fms_performance_config/fms_performance_config.json create mode 100644 test/systemtest/common/fms/fms_performance_test/fms_performance_test.cpp create mode 100644 test/systemtest/common/fms/fms_performance_test/performance_config_parser.h create mode 100644 test/systemtest/common/fms/fms_release_form_test/BUILD.gn create mode 100644 test/systemtest/common/fms/fms_release_form_test/fms_release_form_test.cpp create mode 100644 test/systemtest/common/fms/fms_stress_test/BUILD.gn create mode 100644 test/systemtest/common/fms/fms_stress_test/fms_stress_test.cpp create mode 100644 test/systemtest/common/fms/fms_stress_test/fms_stress_test_config/fms_stress_test_config.json create mode 100644 test/systemtest/common/fms/fms_stress_test/stress_test_config_parser.h diff --git a/test/resource/formsystemtestability/BUILD.gn b/test/resource/formsystemtestability/BUILD.gn index 48b23fa125..cd7d80772f 100644 --- a/test/resource/formsystemtestability/BUILD.gn +++ b/test/resource/formsystemtestability/BUILD.gn @@ -12,5 +12,13 @@ # limitations under the License. group("fms_system_test_app") { - deps = [ "formSystemTestServiceA:formSystemTestServiceA" ] + deps = [ + "fmsSystemPerformance:fmsSystemPerformance", + "fmsSystemStress:fmsSystemStress", + "fmsSystemTestHostCommonA:fmsSystemTestHostCommonA", + "fmsSystemTestHostNoPerm:fmsSystemTestHostNoPerm", + "fmsSystemTestHostNormal:fmsSystemTestHostNormal", + "fmsSystemTestHostNormalB:fmsSystemTestHostNormalB", + "fmsSystemTestHostNotSys:fmsSystemTestHostNotSys", + ] } diff --git a/test/resource/formsystemtestability/fmsSystemPerformance/BUILD.gn b/test/resource/formsystemtestability/fmsSystemPerformance/BUILD.gn new file mode 100755 index 0000000000..2dabcfa7c3 --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemPerformance/BUILD.gn @@ -0,0 +1,70 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import("//build/ohos.gni") +import("//foundation/appexecfwk/standard/appexecfwk.gni") + +config("fmsSystemPerformanceConfig") { + visibility = [ ":*" ] + include_dirs = [ + "include", + "../tool/include", + "${appexecfwk_path}/test/systemtest/common/fms/common/include", + "${aafwk_path}/interfaces/innerkits/ability_manager/include", + "${aafwk_path}/interfaces/innerkits/want/include/ohos/aafwk/content", + "${aafwk_path}/services/abilitymgr/include", + "${appexecfwk_path}/common/log/include", + "${appexecfwk_path}/interfaces/innerkits/libeventhandler/include", + "${appexecfwk_path}/kits/appkit/native/app", + "${appexecfwk_path}/services/bundlemgr/include", + "//foundation/distributedschedule/dmsfwk/services/dtbschedmgr/include", + "//utils/system/safwk/native/include", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core/include/appmgr", + "//third_party/jsoncpp/include", + ] + defines = [ + "APP_LOG_TAG = \"formManagerSystemTest\"", + "LOG_DOMAIN = 0xD002666", + ] +} +ohos_shared_library("fmsSystemPerformance") { + sources = [ + "../tool/src/form_test_utils.cpp", + "src/form_ability_performance.cpp", + ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + configs = [ ":fmsSystemPerformanceConfig" ] + deps = [ + "${aafwk_path}/frameworks/kits/ability/native:abilitykit_native", + "${aafwk_path}/interfaces/innerkits/base:base", + "${aafwk_path}/interfaces/innerkits/want:want", + "${appexecfwk_path}/common:libappexecfwk_common", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core:appexecfwk_core", + "${appexecfwk_path}/kits:appkit_native", + "${appexecfwk_path}/services/bundlemgr:libbms", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//third_party/jsoncpp:jsoncpp", + "//utils/native/base:utilsbase", + ] + external_deps = [ + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] + subsystem_name = "formsystemtestability" +} diff --git a/test/resource/formsystemtestability/fmsSystemPerformance/config.json b/test/resource/formsystemtestability/fmsSystemPerformance/config.json new file mode 100644 index 0000000000..09e073e97b --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemPerformance/config.json @@ -0,0 +1,80 @@ +{ + "app":{ + "bundleName": "com.ohos.form.manager.performance", + "vendor": "ix", + "version": { + "code": 1, + "name": "1.0" + }, + "apiVersion": { + "compatible": 3, + "target": 3 + } + }, + "deviceConfig": { + "default": { + } + }, + "module": { + "package":"com.ohos.form.manager.performance.FormAbility", + "name":"FormAbility", + "deviceType": [ + "phone" + ], + "distro": { + "deliveryWithInstall": true, + "moduleName": "FormAbility", + "moduleType": "entry" + }, + "abilities": [{ + "name": "FormAbilityPerformance", + "icon": "$media:snowball", + "srcLanguage": "c++", + "label": "Form Ability Performance", + "launchType": "standard", + "orientation": "unspecified", + "type": "page", + "visible": true, + "skills": [ + { + "actions": [ + "ohos.aafwk.content.Want.ACTION_HOME" + ], + "entities": [ + "ohos.aafwk.content.Want.ENTITY_HOME" + ], + "attributes": [] + } + ] + }], + "defPermissions": [ + { + "name": "ohos.permission.REQUIRE_FORM", + "grantMode": "system_grant", + "label": "$string:entry_MainAbility", + "description": "REQUIRE_FORM permission in detail" + } + ], + "reqPermissions": [ + { + "name": "ohos.permission.REQUIRE_FORM", + "reason": "fmssystemperformance", + "usedScene": { + "ability": [ + ".MainAbility" + ], + "when": "always" + } + } + ], + "js": [ + { + "name": "formDemo", + "pages": [ + "pages/index/index" + ], + "type": "form" + } + ] + } +} \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemPerformance/include/form_ability_performance.h b/test/resource/formsystemtestability/fmsSystemPerformance/include/form_ability_performance.h new file mode 100644 index 0000000000..0cec1158fd --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemPerformance/include/form_ability_performance.h @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _FORM_ABILITY_PERFORMANCE_H_ +#define _FORM_ABILITY_PERFORMANCE_H_ +#include "ability_loader.h" +#include "common_event.h" +#include "common_event_manager.h" +#include +#include +#include + +using std::string; + +namespace OHOS { +namespace AppExecFwk { + +typedef bool (*FunctionPtr)(); + +class FormEventSubscriber; +class FormAbilityPerformance : public Ability { +public: + void SubscribeEvent(); + void handleEvent(std::string action, std::string data); + + // Test case list + void FMS_performanceTest_0100(std::string data); + void FMS_performanceTest_0200(std::string data); + void FMS_performanceTest_0300(std::string data); + void FMS_performanceTest_0400(std::string data); + void FMS_performanceTest_0500(std::string data); + void FMS_performanceTest_0600(std::string data); + void FMS_performanceTest_0700(std::string data); + void FMS_performanceTest_1300(std::string data); + void FMS_performanceTest_1400(std::string data); + void FMS_performanceTest_1500(std::string data); + void FMS_performanceTest_1600(std::string data); + + std::shared_ptr subscriber_; + + class PerformanceFormCallback : public FormCallback { + public: + PerformanceFormCallback(std::string name, int code):caseName_(name), code_(code) { } + virtual ~PerformanceFormCallback() = default; + void OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnFormUninstall(const int64_t formId) const override; + + std::string caseName_ = ""; + int code_ = 0; + FormAbilityPerformance *ability_; + }; +protected: + virtual void Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) override; + virtual void OnStart(const Want &want) override; + virtual void OnStop() override; + virtual void OnActive() override; + virtual void OnInactive() override; + virtual void OnBackground() override; +private: + void Clear(); + + using FormFunc = void (FormAbilityPerformance::*)(std::string data); + std::map memberFuncMap_; + std::map calledFuncMap_; + std::shared_ptr callback_; + +}; + +class FormEventSubscriber : public EventFwk::CommonEventSubscriber { +public: + FormEventSubscriber(const EventFwk::CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp) + { + ability_ = nullptr; + } + ~FormEventSubscriber() + { + ability_ = nullptr; + } + virtual void OnReceiveEvent(const EventFwk::CommonEventData &data) override; + void KitTerminateAbility(); + + FormAbilityPerformance *ability_; +}; +} // namespace AppExecFwk +} // namespace OHOS +#endif // _FORM_ABILITY_PERFORMANCE_H_ \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemPerformance/src/form_ability_performance.cpp b/test/resource/formsystemtestability/fmsSystemPerformance/src/form_ability_performance.cpp new file mode 100644 index 0000000000..1e9f6859d6 --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemPerformance/src/form_ability_performance.cpp @@ -0,0 +1,372 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "app_log_wrapper.h" +#include "form_ability_performance.h" +#include +#include +#include +#include "form_test_utils.h" +#include "form_st_common_info.h" + +namespace { + using namespace OHOS::AAFwk; + using namespace OHOS::EventFwk; +} + +namespace OHOS { +namespace AppExecFwk { + +std::vector eventList = { + FORM_EVENT_REQ_PERFORMANCE_TEST_0100, + FORM_EVENT_REQ_PERFORMANCE_TEST_0200, + FORM_EVENT_REQ_PERFORMANCE_TEST_0300, + FORM_EVENT_REQ_PERFORMANCE_TEST_0400, + FORM_EVENT_REQ_PERFORMANCE_TEST_0500, + FORM_EVENT_REQ_PERFORMANCE_TEST_0600, + FORM_EVENT_REQ_PERFORMANCE_TEST_0700, + FORM_EVENT_REQ_PERFORMANCE_TEST_1300, + FORM_EVENT_REQ_PERFORMANCE_TEST_1400, + FORM_EVENT_REQ_PERFORMANCE_TEST_1500, + FORM_EVENT_REQ_PERFORMANCE_TEST_1600, +}; + +static std::string g_form_id = 0; +static std::string g_bundleName = "com.form.formsystemtestservicea"; +static std::string g_moduleName = "formmodule001"; +void FormAbilityPerformance::PerformanceFormCallback::OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called", __func__); + APP_LOGI("%{public}s called", __func__); + APP_LOGI("%{public}s formId: %{public}s", __func__, std::to_string(formJsInfo.formId).c_str()); + APP_LOGI("%{public}s bundleName: %{public}s", __func__, formJsInfo.bundleName.c_str()); + APP_LOGI("%{public}s abilityName: %{public}s", __func__, formJsInfo.abilityName.c_str()); + APP_LOGI("%{public}s formName: %{public}s", __func__, formJsInfo.formName.c_str()); + APP_LOGI("%{public}s formTempFlg: %{public}d", __func__, formJsInfo.formTempFlg); + APP_LOGI("%{public}s jsFormCodePath: %{public}s", __func__, formJsInfo.jsFormCodePath.c_str()); + APP_LOGI("%{public}s formData: %{public}s", __func__, formJsInfo.formData.c_str()); + APP_LOGI("%{public}s formProviderData GetDataString: %{public}s", __func__, formJsInfo.formProviderData.GetDataString().c_str()); + + g_form_id = std::to_string(formJsInfo.formId); + + if (this->caseName_ == FORM_EVENT_RECV_PERFORMANCE_TEST_0100) { + FormTestUtils::PublishEvent(this->caseName_, 101, std::to_string(formJsInfo.formId)); + } else if (this->caseName_ == FORM_EVENT_RECV_PERFORMANCE_TEST_0200) { + FormTestUtils::PublishEvent(this->caseName_, 201, std::to_string(formJsInfo.formId)); + } else if (this->caseName_ == FORM_EVENT_RECV_PERFORMANCE_TEST_0300) { + FormTestUtils::PublishEvent(this->caseName_, 301, std::to_string(formJsInfo.formId)); + } else if (this->caseName_ == FORM_EVENT_RECV_PERFORMANCE_TEST_0400) { + FormTestUtils::PublishEvent(this->caseName_, 401, std::to_string(formJsInfo.formId)); + } else if (this->caseName_ == FORM_EVENT_RECV_PERFORMANCE_TEST_0500) { + FormTestUtils::PublishEvent(this->caseName_, 501, std::to_string(formJsInfo.formId)); + } else { + FormTestUtils::PublishEvent(this->caseName_, this->code_ + 1, std::to_string(formJsInfo.formId)); + } +} + +void FormAbilityPerformance::PerformanceFormCallback::OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called", __func__); + APP_LOGI("%{public}s called", __func__); + APP_LOGI("%{public}s formId: %{public}s", __func__, std::to_string(formJsInfo.formId).c_str()); + APP_LOGI("%{public}s bundleName: %{public}s", __func__, formJsInfo.bundleName.c_str()); + APP_LOGI("%{public}s abilityName: %{public}s", __func__, formJsInfo.abilityName.c_str()); + APP_LOGI("%{public}s formName: %{public}s", __func__, formJsInfo.formName.c_str()); + APP_LOGI("%{public}s formTempFlg: %{public}d", __func__, formJsInfo.formTempFlg); + APP_LOGI("%{public}s jsFormCodePath: %{public}s", __func__, formJsInfo.jsFormCodePath.c_str()); + APP_LOGI("%{public}s formData: %{public}s", __func__, formJsInfo.formData.c_str()); + APP_LOGI("%{public}s formProviderData GetDataString: %{public}s", __func__, formJsInfo.formProviderData.GetDataString().c_str()); + + if (this->caseName_ == FORM_EVENT_RECV_PERFORMANCE_TEST_0100) { + FormTestUtils::PublishEvent(this->caseName_, 102, "true"); + } else if (this->caseName_ == FORM_EVENT_RECV_PERFORMANCE_TEST_0200) { + FormTestUtils::PublishEvent(this->caseName_, 202, "true"); + } else if (this->caseName_ == FORM_EVENT_RECV_PERFORMANCE_TEST_0300) { + FormTestUtils::PublishEvent(this->caseName_, 302, "true"); + } else if (this->caseName_ == FORM_EVENT_RECV_PERFORMANCE_TEST_0400) { + FormTestUtils::PublishEvent(this->caseName_, 402, "true"); + } else if (this->caseName_ == FORM_EVENT_RECV_PERFORMANCE_TEST_0500) { + FormTestUtils::PublishEvent(this->caseName_, 502, "true"); + } else { + FormTestUtils::PublishEvent(this->caseName_, this->code_ + 2, "true"); + } +} + +void FormAbilityPerformance::PerformanceFormCallback::OnFormUninstall(const int64_t formId) const +{ + APP_LOGI("%{public}s called", __func__); +} + +void FormAbilityPerformance::FMS_performanceTest_0100(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_PERFORMANCE_TEST_0100, 100); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("Performance testing end"); + } else { + APP_LOGE("Performance testing error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0100, 100, "false"); + } +} + +void FormAbilityPerformance::FMS_performanceTest_0200(std::string data) +{ + bool bResult = DeleteForm(atoll(g_form_id.c_str())); + if(bResult) { + APP_LOGI("[FMS_performanceTest_0200] DeleteForm end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0200, 200, "true"); + } else { + APP_LOGE("[FMS_performanceTest_0200] DeleteForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0200, 200, "false"); + } +} + +void FormAbilityPerformance::FMS_performanceTest_0300(std::string data) +{ + bool isReleaseCache = false; + bool bResult = ReleaseForm(atoll(g_form_id.c_str()), isReleaseCache); + if(bResult) { + APP_LOGI("[FMS_performanceTest_0300] ReleaseForm end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0300, 300, "true"); + } else { + APP_LOGE("[FMS_performanceTest_0300] ReleaseForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0300, 300, "false"); + } +} + +void FormAbilityPerformance::FMS_performanceTest_0400(std::string data) +{ + bool bResult = CastTempForm(atoll(g_form_id.c_str())); + if(bResult) { + APP_LOGI("[FMS_performanceTest_0400] CastTempForm end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0400, 400, "true"); + } else { + APP_LOGE("[FMS_performanceTest_0400] CastTempForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0400, 400, "false"); + } +} + +void FormAbilityPerformance::FMS_performanceTest_0500(std::string data) +{ + std::vector formIds; + formIds.push_back(atoll(g_form_id.c_str())); + bool bResult = NotifyVisibleForms(formIds); + if(bResult) { + APP_LOGI("[FMS_performanceTest_0500] NotifyVisibleForms end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0500, 500, "true"); + } else { + APP_LOGE("[FMS_performanceTest_0500] NotifyVisibleForms error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0500, 500, "false"); + } +} + +void FormAbilityPerformance::FMS_performanceTest_0600(std::string data) +{ + std::vector formIds; + formIds.push_back(atoll(g_form_id.c_str())); + bool bResult = NotifyInvisibleForms(formIds); + if(bResult) { + APP_LOGI("[FMS_performanceTest_0600] NotifyInvisibleForms end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0600, 600, "true"); + } else { + APP_LOGE("[FMS_performanceTest_0600] NotifyInvisibleForms error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0600, 600, "false"); + } +} + +void FormAbilityPerformance::FMS_performanceTest_0700(std::string data) +{ + bool bResult = RequestForm(atoll(g_form_id.c_str())); + if(bResult) { + APP_LOGI("[FMS_performanceTest_0700] RequestForm end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0700, 700, "true"); + } else { + APP_LOGE("[FMS_performanceTest_0700] RequestForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_1300, 700, "false"); + } +} + +void FormAbilityPerformance::FMS_performanceTest_1300(std::string data) +{ + std::vector formInfos; + bool bResult = GetAllFormsInfo(formInfos); + if(bResult) { + APP_LOGI("[FMS_performanceTest_1300] GetAllFormsInfo end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_1300, 1300, "true"); + } else { + APP_LOGE("[FMS_performanceTest_1300] GetAllFormsInfo error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_1300, 1300, "false"); + } +} + +void FormAbilityPerformance::FMS_performanceTest_1400(std::string data) +{ + std::vector formInfos; + bool bResult = GetFormsInfoByApp(g_bundleName, formInfos); + + if(bResult) { + APP_LOGI("[FMS_performanceTest_1400] GetFormsInfoByApp end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_1400, 1400, "true"); + } else { + APP_LOGE("[FMS_performanceTest_1400] GetFormsInfoByApp error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_1400, 1400, "false"); + } +} + +void FormAbilityPerformance::FMS_performanceTest_1500(std::string data) +{ + std::vector formInfos; + bool bResult = GetFormsInfoByModule(g_bundleName, g_moduleName, formInfos); + if(bResult) { + APP_LOGI("[FMS_performanceTest_1500] GetFormsInfoByModule end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_1500, 1500, "true"); + } else { + APP_LOGE("[FMS_performanceTest_1500] GetFormsInfoByModule error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_1500, 1500, "false"); + } +} + +void FormAbilityPerformance::FMS_performanceTest_1600(std::string data) +{ + bool bResult = CheckFMSReady(); + if(bResult) { + APP_LOGI("[FMS_performanceTest_1600] CheckFMSReady end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_1600, 1600, "true"); + } else { + APP_LOGE("[FMS_performanceTest_1600] CheckFMSReady error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_1600, 1600, "false"); + } +} + +void FormAbilityPerformance::OnStart(const Want &want) +{ + APP_LOGI("FormAbilityPerformance::onStart"); + Ability::OnStart(want); + CommonEventManager::UnSubscribeCommonEvent(subscriber_); +} + +void FormAbilityPerformance::OnActive() +{ + APP_LOGI("FormAbilityPerformance::OnActive"); + Ability::OnActive(); + std::string eventData = GetAbilityName() + FORM_ABILITY_STATE_ONACTIVE; + FormTestUtils::PublishEvent(FORM_EVENT_ABILITY_ONACTIVED, 0, eventData); +} + +void FormAbilityPerformance::OnStop() +{ + APP_LOGI("FormAbilityPerformance::OnStop"); + + Ability::OnStop(); +} + +void FormAbilityPerformance::OnInactive() +{ + APP_LOGI("FormAbilityPerformance::OnInactive"); + + Ability::OnInactive(); +} + +void FormAbilityPerformance::OnBackground() +{ + APP_LOGI("FormAbilityPerformance::OnBackground"); + + Ability::OnBackground(); +} + +void FormAbilityPerformance::SubscribeEvent() +{ + MatchingSkills matchingSkills; + for (const auto &e : eventList) { + matchingSkills.AddEvent(e); + } + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + subscribeInfo.SetPriority(1); + subscriber_ = std::make_shared(subscribeInfo); + subscriber_->ability_ = this; + CommonEventManager::SubscribeCommonEvent(subscriber_); +} + +// KitTest End +void FormAbilityPerformance::Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) +{ + APP_LOGI("FormAbilityPerformance::Init"); + Ability::Init(abilityInfo, application, handler, token); + + memberFuncMap_[FORM_EVENT_REQ_PERFORMANCE_TEST_0100] = &FormAbilityPerformance::FMS_performanceTest_0100; + memberFuncMap_[FORM_EVENT_REQ_PERFORMANCE_TEST_0200] = &FormAbilityPerformance::FMS_performanceTest_0200; + memberFuncMap_[FORM_EVENT_REQ_PERFORMANCE_TEST_0300] = &FormAbilityPerformance::FMS_performanceTest_0300; + memberFuncMap_[FORM_EVENT_REQ_PERFORMANCE_TEST_0400] = &FormAbilityPerformance::FMS_performanceTest_0400; + memberFuncMap_[FORM_EVENT_REQ_PERFORMANCE_TEST_0500] = &FormAbilityPerformance::FMS_performanceTest_0500; + memberFuncMap_[FORM_EVENT_REQ_PERFORMANCE_TEST_0600] = &FormAbilityPerformance::FMS_performanceTest_0600; + memberFuncMap_[FORM_EVENT_REQ_PERFORMANCE_TEST_0700] = &FormAbilityPerformance::FMS_performanceTest_0700; + memberFuncMap_[FORM_EVENT_REQ_PERFORMANCE_TEST_1300] = &FormAbilityPerformance::FMS_performanceTest_1300; + memberFuncMap_[FORM_EVENT_REQ_PERFORMANCE_TEST_1400] = &FormAbilityPerformance::FMS_performanceTest_1400; + memberFuncMap_[FORM_EVENT_REQ_PERFORMANCE_TEST_1500] = &FormAbilityPerformance::FMS_performanceTest_1500; + memberFuncMap_[FORM_EVENT_REQ_PERFORMANCE_TEST_1600] = &FormAbilityPerformance::FMS_performanceTest_1600; + + SubscribeEvent(); +} + +void FormAbilityPerformance::handleEvent(std::string action, std::string data) +{ + APP_LOGI("%{public}s called", __func__); + if(calledFuncMap_.find(action) != calledFuncMap_.end()) { + return; + } + calledFuncMap_.emplace(action, 0); + auto itFunc = memberFuncMap_.find(action); + if (itFunc != memberFuncMap_.end()) { + auto memberFunc = itFunc->second; + if (memberFunc != nullptr) { + return (this->*memberFunc)(data); + } + } +} + +void FormAbilityPerformance::Clear() +{ +} + +void FormEventSubscriber::OnReceiveEvent(const CommonEventData &data) +{ + APP_LOGI("FormEventSubscriber::OnReceiveEvent:event=%{public}s, code=%{public}d, data=%{public}s", + data.GetWant().GetAction().c_str(), data.GetCode(), data.GetData().c_str()); + auto eventName = data.GetWant().GetAction(); + ability_->handleEvent(eventName, data.GetData()); + CommonEventManager::UnSubscribeCommonEvent(ability_->subscriber_); +} + +void FormEventSubscriber::KitTerminateAbility() +{ + if (ability_ != nullptr) { + ability_->TerminateAbility(); + } +} + +REGISTER_AA(FormAbilityPerformance) +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemStress/BUILD.gn b/test/resource/formsystemtestability/fmsSystemStress/BUILD.gn new file mode 100755 index 0000000000..de3f0bad09 --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemStress/BUILD.gn @@ -0,0 +1,70 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import("//build/ohos.gni") +import("//foundation/appexecfwk/standard/appexecfwk.gni") + +config("fmsSystemStressConfig") { + visibility = [ ":*" ] + include_dirs = [ + "include", + "../tool/include", + "${appexecfwk_path}/test/systemtest/common/fms/common/include", + "${aafwk_path}/interfaces/innerkits/ability_manager/include", + "${aafwk_path}/interfaces/innerkits/want/include/ohos/aafwk/content", + "${aafwk_path}/services/abilitymgr/include", + "${appexecfwk_path}/common/log/include", + "${appexecfwk_path}/interfaces/innerkits/libeventhandler/include", + "${appexecfwk_path}/kits/appkit/native/app", + "${appexecfwk_path}/services/bundlemgr/include", + "//foundation/distributedschedule/dmsfwk/services/dtbschedmgr/include", + "//utils/system/safwk/native/include", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core/include/appmgr", + "//third_party/jsoncpp/include", + ] + defines = [ + "APP_LOG_TAG = \"formManagerSystemTest\"", + "LOG_DOMAIN = 0xD002666", + ] +} +ohos_shared_library("fmsSystemStress") { + sources = [ + "../tool/src/form_test_utils.cpp", + "src/form_ability_stress.cpp", + ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + configs = [ ":fmsSystemStressConfig" ] + deps = [ + "${aafwk_path}/frameworks/kits/ability/native:abilitykit_native", + "${aafwk_path}/interfaces/innerkits/base:base", + "${aafwk_path}/interfaces/innerkits/want:want", + "${appexecfwk_path}/common:libappexecfwk_common", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core:appexecfwk_core", + "${appexecfwk_path}/kits:appkit_native", + "${appexecfwk_path}/services/bundlemgr:libbms", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//third_party/jsoncpp:jsoncpp", + "//utils/native/base:utilsbase", + ] + external_deps = [ + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] + subsystem_name = "formsystemtestability" +} diff --git a/test/resource/formsystemtestability/fmsSystemStress/config.json b/test/resource/formsystemtestability/fmsSystemStress/config.json new file mode 100644 index 0000000000..8124df3ddc --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemStress/config.json @@ -0,0 +1,80 @@ +{ + "app":{ + "bundleName": "com.ohos.form.manager.stress", + "vendor": "ix", + "version": { + "code": 1, + "name": "1.0" + }, + "apiVersion": { + "compatible": 3, + "target": 3 + } + }, + "deviceConfig": { + "default": { + } + }, + "module": { + "package":"com.ohos.form.manager.stress.FormAbility", + "name":"FormAbility", + "deviceType": [ + "phone" + ], + "distro": { + "deliveryWithInstall": true, + "moduleName": "FormAbility", + "moduleType": "entry" + }, + "abilities": [{ + "name": "FormAbilityStress", + "icon": "$media:snowball", + "srcLanguage": "c++", + "label": "Form Ability Stress", + "launchType": "standard", + "orientation": "unspecified", + "type": "page", + "visible": true, + "skills": [ + { + "actions": [ + "ohos.aafwk.content.Want.ACTION_HOME" + ], + "entities": [ + "ohos.aafwk.content.Want.ENTITY_HOME" + ], + "attributes": [] + } + ] + }], + "defPermissions": [ + { + "name": "ohos.permission.REQUIRE_FORM", + "grantMode": "system_grant", + "label": "$string:entry_MainAbility", + "description": "REQUIRE_FORM permission in detail" + } + ], + "reqPermissions": [ + { + "name": "ohos.permission.REQUIRE_FORM", + "reason": "fmsstresstest", + "usedScene": { + "ability": [ + ".MainAbility" + ], + "when": "always" + } + } + ], + "js": [ + { + "name": "formDemo", + "pages": [ + "pages/index/index" + ], + "type": "form" + } + ] + } +} \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemStress/include/form_ability_stress.h b/test/resource/formsystemtestability/fmsSystemStress/include/form_ability_stress.h new file mode 100644 index 0000000000..6b53b3ec80 --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemStress/include/form_ability_stress.h @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _FORM_ABILITY_STRESS_H_ +#define _FORM_ABILITY_STRESS_H_ +#include "ability_loader.h" +#include "common_event.h" +#include "common_event_manager.h" +#include +#include +#include + +using std::string; + +namespace OHOS { +namespace AppExecFwk { + +typedef bool (*FunctionPtr)(); + +class FormEventSubscriber; +class FormAbilityStress : public Ability { +public: + void SubscribeEvent(); + void handleEvent(std::string action, std::string data); + + // Test case list + void FMS_stressTest_0100(std::string data); + void FMS_stressTest_0100_sub01(std::string form_id); + void FMS_stressTest_0200(std::string data); + void FMS_stressTest_0200_sub01(std::string form_id); + void FMS_stressTest_0200_sub02(std::string form_id); + void FMS_stressTest_0200_sub03(std::string form_id); + void FMS_stressTest_0300(std::string data); + void FMS_stressTest_0300_sub01(std::string form_id); + void FMS_stressTest_0300_sub02(std::string form_id); + void FMS_stressTest_0400(std::string data); + void FMS_stressTest_0500(std::string data); + void FMS_stressTest_0600(std::string data); + void FMS_stressTest_0700(std::string data); + void FMS_stressTest_0800(std::string data); + void FMS_stressTest_0900(std::string data); + void FMS_stressTest_1000(std::string data); + void FMS_stressTest_1100(std::string data); + void FMS_stressTest_1100_sub01(std::string form_id); + void FMS_stressTest_1100_sub02(std::string form_id); + void FMS_stressTest_1100_sub03(std::string form_id); + void FMS_stressTest_1200(std::string data); + void FMS_stressTest_1300(std::string data); + void FMS_stressTest_1300_sub01(std::string form_id); + void FMS_stressTest_1300_sub02(std::string form_id); + void FMS_stressTest_1300_sub03(std::string form_id); + void FMS_stressTest_1400(std::string data); + void FMS_stressTest_1500(std::string data); + void FMS_stressTest_1600(std::string data); + void FMS_stressTest_1700(std::string data); + void FMS_stressTest_1700_sub01(std::string data); + void FMS_stressTest_1700_sub02(std::string data); + void FMS_stressTest_1800(std::string data); + + std::shared_ptr subscriber_; + + class StressFormCallback : public FormCallback { + public: + StressFormCallback(std::string name, int code):caseName_(name), code_(code) { } + virtual ~StressFormCallback() = default; + void OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnFormUninstall(const int64_t formId) const override; + + std::string caseName_ = ""; + int code_ = 0; + FormAbilityStress *ability_; + }; +protected: + virtual void Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) override; + virtual void OnStart(const Want &want) override; + virtual void OnStop() override; + virtual void OnActive() override; + virtual void OnInactive() override; + virtual void OnBackground() override; +private: + void Clear(); + using FormFunc = void (FormAbilityStress::*)(std::string data); + std::map memberFuncMap_; + std::map calledFuncMap_; + std::shared_ptr callback_; +}; + +class FormEventSubscriber : public EventFwk::CommonEventSubscriber { +public: + FormEventSubscriber(const EventFwk::CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp) + { + ability_ = nullptr; + } + ~FormEventSubscriber() + { + ability_ = nullptr; + } + virtual void OnReceiveEvent(const EventFwk::CommonEventData &data) override; + void KitTerminateAbility(); + + FormAbilityStress *ability_; +}; +} // namespace AppExecFwk +} // namespace OHOS +#endif // _FORM_ABILITY_STRESS_H_ \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemStress/src/form_ability_stress.cpp b/test/resource/formsystemtestability/fmsSystemStress/src/form_ability_stress.cpp new file mode 100644 index 0000000000..5cf95bacda --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemStress/src/form_ability_stress.cpp @@ -0,0 +1,659 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "app_log_wrapper.h" +#include "form_ability_stress.h" +#include +#include +#include +#include "form_test_utils.h" +#include "form_st_common_info.h" + +namespace { + using namespace OHOS::AAFwk; + using namespace OHOS::EventFwk; +} + +namespace OHOS { +namespace AppExecFwk { + +std::vector eventList = { + FORM_EVENT_REQ_STRESS_TEST_0100, FORM_EVENT_REQ_STRESS_TEST_0100_01, FORM_EVENT_REQ_STRESS_TEST_0200, + FORM_EVENT_REQ_STRESS_TEST_0200_01, FORM_EVENT_REQ_STRESS_TEST_0200_02, FORM_EVENT_REQ_STRESS_TEST_0200_03, + FORM_EVENT_REQ_STRESS_TEST_0300, FORM_EVENT_REQ_STRESS_TEST_0300_01, FORM_EVENT_REQ_STRESS_TEST_0300_02, + FORM_EVENT_REQ_STRESS_TEST_0400, FORM_EVENT_REQ_STRESS_TEST_0500, + FORM_EVENT_REQ_STRESS_TEST_1100, FORM_EVENT_REQ_STRESS_TEST_1100_01, FORM_EVENT_REQ_STRESS_TEST_1100_02, + FORM_EVENT_REQ_STRESS_TEST_1100_03, FORM_EVENT_REQ_STRESS_TEST_1300, FORM_EVENT_REQ_STRESS_TEST_1300_01, + FORM_EVENT_REQ_STRESS_TEST_1300_02, FORM_EVENT_REQ_STRESS_TEST_1300_03, + FORM_EVENT_REQ_STRESS_TEST_1700, FORM_EVENT_REQ_STRESS_TEST_1700_01, FORM_EVENT_REQ_STRESS_TEST_1700_02, + FORM_EVENT_REQ_STRESS_TEST_1800, +}; + +static std::string g_bundleName = "com.form.formsystemtestservicea"; +static std::string g_moduleName = "formmodule001"; +void FormAbilityStress::StressFormCallback::OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called", __func__); + APP_LOGI("%{public}s formId: %{public}s", __func__, std::to_string(formJsInfo.formId).c_str()); + APP_LOGI("%{public}s bundleName: %{public}s", __func__, formJsInfo.bundleName.c_str()); + APP_LOGI("%{public}s abilityName: %{public}s", __func__, formJsInfo.abilityName.c_str()); + APP_LOGI("%{public}s formName: %{public}s", __func__, formJsInfo.formName.c_str()); + APP_LOGI("%{public}s formTempFlg: %{public}d", __func__, formJsInfo.formTempFlg); + APP_LOGI("%{public}s jsFormCodePath: %{public}s", __func__, formJsInfo.jsFormCodePath.c_str()); + APP_LOGI("%{public}s formData: %{public}s", __func__, formJsInfo.formData.c_str()); + APP_LOGI("%{public}s formProviderData GetDataString: %{public}s", __func__, formJsInfo.formProviderData.GetDataString().c_str()); + + if (this->caseName_ == FORM_EVENT_RECV_STRESS_TEST_0100) { + FormTestUtils::PublishEvent(this->caseName_, 101, std::to_string(formJsInfo.formId)); + } else if (this->caseName_ == FORM_EVENT_RECV_STRESS_TEST_0200) { + FormTestUtils::PublishEvent(this->caseName_, 201, std::to_string(formJsInfo.formId)); + } else if (this->caseName_ == FORM_EVENT_RECV_STRESS_TEST_0200_02) { + FormTestUtils::PublishEvent(this->caseName_, 204, "true"); + ability_->FMS_stressTest_0200_sub03(std::to_string(formJsInfo.formId)); + } else if (this->caseName_ == FORM_EVENT_RECV_STRESS_TEST_0300) { + FormTestUtils::PublishEvent(this->caseName_, 301, std::to_string(formJsInfo.formId)); + } else if (this->caseName_ == FORM_EVENT_RECV_STRESS_TEST_0400) { + FormTestUtils::PublishEvent(this->caseName_, 401, std::to_string(formJsInfo.formId)); + } else if (this->caseName_ == FORM_EVENT_RECV_STRESS_TEST_1100) { + FormTestUtils::PublishEvent(this->caseName_, 1101, std::to_string(formJsInfo.formId)); + } else if (this->caseName_ == FORM_EVENT_RECV_STRESS_TEST_1300) { + FormTestUtils::PublishEvent(this->caseName_, 1301, std::to_string(formJsInfo.formId)); + } else if (this->caseName_ == FORM_EVENT_RECV_STRESS_TEST_1700) { + FormTestUtils::PublishEvent(this->caseName_, 1701, std::to_string(formJsInfo.formId)); + } else if (this->caseName_ == FORM_EVENT_RECV_STRESS_TEST_1800) { + FormTestUtils::PublishEvent(this->caseName_, 1801, std::to_string(formJsInfo.formId)); + } else { + FormTestUtils::PublishEvent(this->caseName_, this->code_ + 1, std::to_string(formJsInfo.formId)); + } + + APP_LOGI("%{public}s caseName_: %{public}s, code_: %{public}d", __func__, this->caseName_.c_str(), this->code_); +} + +void FormAbilityStress::StressFormCallback::OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called", __func__); + APP_LOGI("%{public}s formId: %{public}s", __func__, std::to_string(formJsInfo.formId).c_str()); + APP_LOGI("%{public}s bundleName: %{public}s", __func__, formJsInfo.bundleName.c_str()); + APP_LOGI("%{public}s abilityName: %{public}s", __func__, formJsInfo.abilityName.c_str()); + APP_LOGI("%{public}s formName: %{public}s", __func__, formJsInfo.formName.c_str()); + APP_LOGI("%{public}s formTempFlg: %{public}d", __func__, formJsInfo.formTempFlg); + APP_LOGI("%{public}s jsFormCodePath: %{public}s", __func__, formJsInfo.jsFormCodePath.c_str()); + APP_LOGI("%{public}s formData: %{public}s", __func__, formJsInfo.formData.c_str()); + APP_LOGI("%{public}s formProviderData GetDataString: %{public}s", __func__, formJsInfo.formProviderData.GetDataString().c_str()); + + if (this->caseName_ == FORM_EVENT_RECV_STRESS_TEST_0100) { + FormTestUtils::PublishEvent(this->caseName_, 102, "true"); + ability_->FMS_stressTest_0100_sub01(std::to_string(formJsInfo.formId)); + } else if (this->caseName_ == FORM_EVENT_RECV_STRESS_TEST_0200) { + FormTestUtils::PublishEvent(this->caseName_, 202, "true"); + ability_->FMS_stressTest_0200_sub01(std::to_string(formJsInfo.formId)); + } else if (this->caseName_ == FORM_EVENT_RECV_STRESS_TEST_0300) { + FormTestUtils::PublishEvent(this->caseName_, 302, "true"); + ability_->FMS_stressTest_0300_sub01(std::to_string(formJsInfo.formId)); + } else if (this->caseName_ == FORM_EVENT_RECV_STRESS_TEST_0400) { + FormTestUtils::PublishEvent(this->caseName_, 402, "true"); + } else if (this->caseName_ == FORM_EVENT_RECV_STRESS_TEST_1100) { + FormTestUtils::PublishEvent(this->caseName_, 1102, "true"); + ability_->FMS_stressTest_1100_sub01(std::to_string(formJsInfo.formId)); + } else if (this->caseName_ == FORM_EVENT_RECV_STRESS_TEST_1300) { + FormTestUtils::PublishEvent(this->caseName_, 1302, "true"); + ability_->FMS_stressTest_1300_sub01(std::to_string(formJsInfo.formId)); + } else if (this->caseName_ == FORM_EVENT_RECV_STRESS_TEST_1700) { + FormTestUtils::PublishEvent(this->caseName_, 1702, "true"); + } else if (this->caseName_ == FORM_EVENT_RECV_STRESS_TEST_1800) { + FormTestUtils::PublishEvent(this->caseName_, 1802, "true"); + } else { + FormTestUtils::PublishEvent(this->caseName_, this->code_ + 2, "true"); + } + + APP_LOGI("%{public}s caseName_: %{public}s, code_: %{public}d", __func__, this->caseName_.c_str(), this->code_); +} + +void FormAbilityStress::StressFormCallback::OnFormUninstall(const int64_t formId) const +{ + APP_LOGI("%{public}s called", __func__); +} + +void FormAbilityStress::FMS_stressTest_0100(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_STRESS_TEST_0100, 100); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_stressTest_0100] AcquireForm end"); + } else { + APP_LOGE("[FMS_stressTest_0100] AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_0100, 100, "false"); + } +} + +void FormAbilityStress::FMS_stressTest_0100_sub01(std::string form_id) +{ + bool bResult = DeleteForm(atoll(form_id.c_str())); + if(bResult) { + APP_LOGI("[FMS_stressTest_0100] DeleteForm end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_0100_01, 103, "true"); + } else { + APP_LOGE("[FMS_stressTest_0100] DeleteForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_0100_01, 103, "false"); + } +} + +void FormAbilityStress::FMS_stressTest_0200(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_STRESS_TEST_0200, 200); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_stressTest_0200] AcquireForm end"); + } else { + APP_LOGE("[FMS_stressTest_0200] AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_0200, 200, "false"); + } +} + +void FormAbilityStress::FMS_stressTest_0200_sub01(std::string form_id) +{ + bool isReleaseCache = false; + bool bResult = ReleaseForm(atoll(form_id.c_str()), isReleaseCache); + if(bResult) { + APP_LOGI("[FMS_stressTest_0200] ReleaseForm end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_0200_01, 203, "true"); + } else { + APP_LOGE("[FMS_stressTest_0200] ReleaseForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_0200_01, 203, "false"); + } + + FormAbilityStress::FMS_stressTest_0200_sub02(form_id); +} + +void FormAbilityStress::FMS_stressTest_0200_sub02(std::string form_id) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_STRESS_TEST_0200_02, 204); + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(atoll(form_id.c_str()), want, callback); + if(bResult) { + APP_LOGI("[FMS_stressTest_0200] AcquireForm sub02 end"); + } else { + APP_LOGE("[FMS_stressTest_0200] AcquireForm sub02 error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_0200_02, 204, "false"); + } + + FormAbilityStress::FMS_stressTest_0200_sub03(form_id); +} + +void FormAbilityStress::FMS_stressTest_0200_sub03(std::string form_id) +{ + bool bResult = DeleteForm(atoll(form_id.c_str())); + if(bResult) { + APP_LOGI("[FMS_stressTest_0200] DeleteForm end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_0200_03, 205, "true"); + } else { + APP_LOGE("[FMS_stressTest_0200] DeleteForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_0200_03, 205, "false"); + } +} + +void FormAbilityStress::FMS_stressTest_0300(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_STRESS_TEST_0300, 300); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_TRUE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_stressTest_0300] AcquireForm end"); + } else { + APP_LOGE("[FMS_stressTest_0300] AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_0300, 300, "false"); + } +} + +void FormAbilityStress::FMS_stressTest_0300_sub01(std::string form_id) +{ + bool bResult = CastTempForm(atoll(form_id.c_str())); + if(bResult) { + APP_LOGI("[FMS_stressTest_0300] CastTempForm end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_0300_01, 303, "true"); + } else { + APP_LOGE("[FMS_stressTest_0300] CastTempForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_0300_01, 303, "false"); + } + + FormAbilityStress::FMS_stressTest_0300_sub02(form_id); +} + +void FormAbilityStress::FMS_stressTest_0300_sub02(std::string form_id) +{ + bool bResult = DeleteForm(atoll(form_id.c_str())); + if(bResult) { + APP_LOGI("[FMS_stressTest_0300] DeleteForm end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_0300_02, 304, "true"); + } else { + APP_LOGE("[FMS_stressTest_0300] DeleteForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_0300_02, 304, "false"); + } +} + +void FormAbilityStress::FMS_stressTest_0400(std::string data) +{ +} + +void FormAbilityStress::FMS_stressTest_0500(std::string data) +{ +} + +void FormAbilityStress::FMS_stressTest_0600(std::string data) +{ +} + +void FormAbilityStress::FMS_stressTest_0700(std::string data) +{ +} + +void FormAbilityStress::FMS_stressTest_1000(std::string data) +{ +} + +void FormAbilityStress::FMS_stressTest_1100(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_STRESS_TEST_1100, 1100); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_stressTest_1100] AcquireForm end"); + } else { + APP_LOGE("[FMS_stressTest_1100] AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1100, 1100, "false"); + } +} + +void FormAbilityStress::FMS_stressTest_1100_sub01(std::string form_id) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_STRESS_TEST_1100_01, 1103); + + std::vector formIds; + formIds.push_back(atoll(form_id.c_str())); + bool bResult = NotifyInvisibleForms(formIds); + if(bResult) { + APP_LOGI("[FMS_stressTest_1100] NotifyInvisibleForms end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1100_01, 1103, "true"); + } else { + APP_LOGE("[FMS_stressTest_1100] NotifyInvisibleForms error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1100_01, 1103, "false"); + } + + FormAbilityStress::FMS_stressTest_1100_sub02(form_id); +} + +void FormAbilityStress::FMS_stressTest_1100_sub02(std::string form_id) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_STRESS_TEST_1100_02, 1104); + + std::vector formIds; + formIds.push_back(atoll(form_id.c_str())); + bool bResult = NotifyVisibleForms(formIds); + if(bResult) { + APP_LOGI("[FMS_stressTest_1100] NotifyVisibleForms end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1100_02, 1104, "true"); + } else { + APP_LOGE("[FMS_stressTest_1100] NotifyVisibleForms error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1100_02, 1104, "false"); + } + + FormAbilityStress::FMS_stressTest_1100_sub03(form_id); +} + +void FormAbilityStress::FMS_stressTest_1100_sub03(std::string form_id) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_STRESS_TEST_1100_03, 1105); + + bool bResult = DeleteForm(atoll(form_id.c_str())); + if(bResult) { + APP_LOGI("[FMS_stressTest_1100] DeleteForm end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1100_03, 1105, "true"); + } else { + APP_LOGE("[FMS_stressTest_1100] DeleteForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1100_03, 1105, "false"); + } +} + +void FormAbilityStress::FMS_stressTest_1200(std::string data) +{ +} + +void FormAbilityStress::FMS_stressTest_1300(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_STRESS_TEST_1300, 1300); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_stressTest_1300] AcquireForm end"); + } else { + APP_LOGE("[FMS_stressTest_1300] AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1300, 1300, "false"); + } +} + +void FormAbilityStress::FMS_stressTest_1300_sub01(std::string form_id) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_STRESS_TEST_1300_01, 1303); + + std::vector formIds; + formIds.push_back(atoll(form_id.c_str())); + bool bResult = EnableUpdateForm(formIds); + if(bResult) { + APP_LOGI("[FMS_stressTest_1300] EnableUpdateForm end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1300_01, 1303, "true"); + } else { + APP_LOGE("[FMS_stressTest_1300] EnableUpdateForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1300_01, 1303, "false"); + } + + FormAbilityStress::FMS_stressTest_1300_sub02(form_id); +} + +void FormAbilityStress::FMS_stressTest_1300_sub02(std::string form_id) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_STRESS_TEST_1300_02, 1304); + + std::vector formIds; + formIds.push_back(atoll(form_id.c_str())); + bool bResult = DisableUpdateForm(formIds); + if(bResult) { + APP_LOGI("[FMS_stressTest_1300] DisableUpdateForm end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1300_02, 1304, "true"); + } else { + APP_LOGE("[FMS_stressTest_1300] DisableUpdateForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1300_02, 1304, "false"); + } + + FormAbilityStress::FMS_stressTest_1300_sub03(form_id); +} + +void FormAbilityStress::FMS_stressTest_1300_sub03(std::string form_id) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_STRESS_TEST_1300_03, 1305); + + bool bResult = DeleteForm(atoll(form_id.c_str())); + if(bResult) { + APP_LOGI("[FMS_stressTest_1300] DeleteForm end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1300_03, 1305, "true"); + } else { + APP_LOGE("[FMS_stressTest_1300] DeleteForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1300_03, 1305, "false"); + } +} + +void FormAbilityStress::FMS_stressTest_1400(std::string data) +{ +} + +void FormAbilityStress::FMS_stressTest_1500(std::string data) +{ +} + +void FormAbilityStress::FMS_stressTest_1600(std::string data) +{ +} + +void FormAbilityStress::FMS_stressTest_1700(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_STRESS_TEST_1700, 1700); + + std::vector formInfos; + bool bResult = GetAllFormsInfo(formInfos); + if(bResult) { + APP_LOGI("[FMS_stressTest_1700] GetAllFormsInfo end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1700, 1700, "true"); + } else { + APP_LOGE("[FMS_stressTest_1700] GetAllFormsInfo error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1700, 1700, "false"); + } + + FormAbilityStress::FMS_stressTest_1700_sub01(data); +} + +void FormAbilityStress::FMS_stressTest_1700_sub01(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_STRESS_TEST_1700_01, 1701); + + std::vector formInfos; + bool bResult = GetFormsInfoByApp(g_bundleName, formInfos); + + if(bResult) { + APP_LOGI("[FMS_stressTest_1700] GetFormsInfoByApp end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1700_01, 1701, "true"); + } else { + APP_LOGE("[FMS_stressTest_1700] GetFormsInfoByApp error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1700_01, 1701, "false"); + } + + FormAbilityStress::FMS_stressTest_1700_sub02(data); +} + +void FormAbilityStress::FMS_stressTest_1700_sub02(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_STRESS_TEST_1700_02, 1702); + + std::vector formInfos; + bool bResult = GetFormsInfoByModule(g_bundleName, g_moduleName, formInfos); + if(bResult) { + APP_LOGI("[FMS_stressTest_1700] GetFormsInfoByModule end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1700_02, 1702, "true"); + } else { + APP_LOGE("[FMS_stressTest_1700] GetFormsInfoByModule error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1700_02, 1702, "false"); + } +} + +void FormAbilityStress::FMS_stressTest_1800(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_STRESS_TEST_1800, 1800); + + bool bResult = CheckFMSReady(); + if(bResult) { + APP_LOGI("[FMS_stressTest_1800] CheckFMSReady end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1800, 1800, "true"); + } else { + APP_LOGE("[FMS_stressTest_1800] CheckFMSReady error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_STRESS_TEST_1800, 1800, "false"); + } +} + +void FormAbilityStress::OnStart(const Want &want) +{ + APP_LOGI("FormAbilityStress::onStart"); + Ability::OnStart(want); +} + +void FormAbilityStress::OnActive() +{ + APP_LOGI("FormAbilityStress::OnActive"); + Ability::OnActive(); + std::string eventData = GetAbilityName() + FORM_ABILITY_STATE_ONACTIVE; + FormTestUtils::PublishEvent(FORM_EVENT_ABILITY_ONACTIVED, 0, eventData); +} + +void FormAbilityStress::OnStop() +{ + APP_LOGI("FormAbilityStress::OnStop"); + + Ability::OnStop(); + CommonEventManager::UnSubscribeCommonEvent(subscriber_); +} + +void FormAbilityStress::OnInactive() +{ + APP_LOGI("FormAbilityStress::OnInactive"); + + Ability::OnInactive(); +} + +void FormAbilityStress::OnBackground() +{ + APP_LOGI("FormAbilityStress::OnBackground"); + + Ability::OnBackground(); +} + +void FormAbilityStress::SubscribeEvent() +{ + APP_LOGI("FormAbilityStress::SubscribeEvent"); + MatchingSkills matchingSkills; + for (const auto &e : eventList) { + matchingSkills.AddEvent(e); + } + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + subscribeInfo.SetPriority(1); + subscriber_ = std::make_shared(subscribeInfo); + subscriber_->ability_ = this; + CommonEventManager::SubscribeCommonEvent(subscriber_); +} + +// KitTest End +void FormAbilityStress::Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) +{ + APP_LOGI("FormAbilityStress::Init"); + Ability::Init(abilityInfo, application, handler, token); + + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_0100] = &FormAbilityStress::FMS_stressTest_0100; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_0100_01] = &FormAbilityStress::FMS_stressTest_0100_sub01; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_0200] = &FormAbilityStress::FMS_stressTest_0200; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_0200_01] = &FormAbilityStress::FMS_stressTest_0200_sub01; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_0200_02] = &FormAbilityStress::FMS_stressTest_0200_sub02; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_0200_03] = &FormAbilityStress::FMS_stressTest_0200_sub03; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_0300] = &FormAbilityStress::FMS_stressTest_0300; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_0300_01] = &FormAbilityStress::FMS_stressTest_0300_sub01; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_0300_02] = &FormAbilityStress::FMS_stressTest_0300_sub02; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_0400] = &FormAbilityStress::FMS_stressTest_0400; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_0500] = &FormAbilityStress::FMS_stressTest_0500; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_1100] = &FormAbilityStress::FMS_stressTest_1100; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_1100_01] = &FormAbilityStress::FMS_stressTest_1100_sub01; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_1100_02] = &FormAbilityStress::FMS_stressTest_1100_sub02; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_1100_03] = &FormAbilityStress::FMS_stressTest_1100_sub03; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_1300] = &FormAbilityStress::FMS_stressTest_1300; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_1300_01] = &FormAbilityStress::FMS_stressTest_1300_sub01; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_1300_02] = &FormAbilityStress::FMS_stressTest_1300_sub02; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_1300_03] = &FormAbilityStress::FMS_stressTest_1300_sub03; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_1700] = &FormAbilityStress::FMS_stressTest_1700; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_1700_01] = &FormAbilityStress::FMS_stressTest_1700_sub01; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_1700_02] = &FormAbilityStress::FMS_stressTest_1700_sub02; + memberFuncMap_[FORM_EVENT_REQ_STRESS_TEST_1800] = &FormAbilityStress::FMS_stressTest_1800; + + SubscribeEvent(); +} + +void FormAbilityStress::handleEvent(std::string action, std::string data) +{ + APP_LOGI("%{public}s called", __func__); + if(calledFuncMap_.find(action) != calledFuncMap_.end()) { + return; + } + calledFuncMap_.emplace(action, 0); + auto itFunc = memberFuncMap_.find(action); + if (itFunc != memberFuncMap_.end()) { + auto memberFunc = itFunc->second; + if (memberFunc != nullptr) { + return (this->*memberFunc)(data); + } + } +} + +void FormAbilityStress::Clear() +{ +} + +void FormEventSubscriber::OnReceiveEvent(const CommonEventData &data) +{ + APP_LOGI("FormEventSubscriber::OnReceiveEvent:event=%{public}s, code=%{public}d, data=%{public}s", + data.GetWant().GetAction().c_str(), data.GetCode(), data.GetData().c_str()); + auto eventName = data.GetWant().GetAction(); + ability_->handleEvent(eventName, data.GetData()); + CommonEventManager::UnSubscribeCommonEvent(ability_->subscriber_); +} + +void FormEventSubscriber::KitTerminateAbility() +{ + if (ability_ != nullptr) { + ability_->TerminateAbility(); + } +} + +REGISTER_AA(FormAbilityStress) +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostCommonA/BUILD.gn b/test/resource/formsystemtestability/fmsSystemTestHostCommonA/BUILD.gn new file mode 100644 index 0000000000..dd65e46f37 --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostCommonA/BUILD.gn @@ -0,0 +1,70 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import("//build/ohos.gni") +import("//foundation/appexecfwk/standard/appexecfwk.gni") + +config("fmsSystemTestHostCommonAConfig") { + visibility = [ ":*" ] + include_dirs = [ + "include", + "../tool/include", + "${appexecfwk_path}/test/systemtest/common/fms/common/include", + "${aafwk_path}/interfaces/innerkits/ability_manager/include", + "${aafwk_path}/interfaces/innerkits/want/include/ohos/aafwk/content", + "${aafwk_path}/services/abilitymgr/include", + "${appexecfwk_path}/common/log/include", + "${appexecfwk_path}/interfaces/innerkits/libeventhandler/include", + "${appexecfwk_path}/kits/appkit/native/app", + "${appexecfwk_path}/services/bundlemgr/include", + "//foundation/distributedschedule/dmsfwk/services/dtbschedmgr/include", + "//utils/system/safwk/native/include", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core/include/appmgr", + "//third_party/jsoncpp/include", + ] + defines = [ + "APP_LOG_TAG = \"formManagerSystemTest\"", + "LOG_DOMAIN = 0xD002666", + ] +} +ohos_shared_library("fmsSystemTestHostCommonA") { + sources = [ + "../tool/src/form_test_utils.cpp", + "src/form_ability_commona.cpp", + ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + configs = [ ":fmsSystemTestHostCommonAConfig" ] + deps = [ + "${aafwk_path}/frameworks/kits/ability/native:abilitykit_native", + "${aafwk_path}/interfaces/innerkits/base:base", + "${aafwk_path}/interfaces/innerkits/want:want", + "${appexecfwk_path}/common:libappexecfwk_common", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core:appexecfwk_core", + "${appexecfwk_path}/kits:appkit_native", + "${appexecfwk_path}/services/bundlemgr:libbms", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//third_party/jsoncpp:jsoncpp", + "//utils/native/base:utilsbase", + ] + external_deps = [ + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] + subsystem_name = "formsystemtestability" +} diff --git a/test/resource/formsystemtestability/fmsSystemTestHostCommonA/config.json b/test/resource/formsystemtestability/fmsSystemTestHostCommonA/config.json new file mode 100644 index 0000000000..81bf59d215 --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostCommonA/config.json @@ -0,0 +1,80 @@ +{ + "app":{ + "bundleName": "com.ohos.form.manager.commona", + "vendor": "ix", + "version": { + "code": 1, + "name": "1.0" + }, + "apiVersion": { + "compatible": 3, + "target": 3 + } + }, + "deviceConfig": { + "default": { + } + }, + "module": { + "package":"com.ohos.form.manager.commona.FormAbility", + "name":"FormAbility", + "deviceType": [ + "phone" + ], + "distro": { + "deliveryWithInstall": true, + "moduleName": "FormAbility", + "moduleType": "entry" + }, + "abilities": [{ + "name": "FormAbilityCommonA", + "icon": "$media:snowball", + "srcLanguage": "c++", + "label": "Form Ability A", + "launchType": "standard", + "orientation": "unspecified", + "type": "page", + "visible": true, + "skills": [ + { + "actions": [ + "ohos.aafwk.content.Want.ACTION_HOME" + ], + "entities": [ + "ohos.aafwk.content.Want.ENTITY_HOME" + ], + "attributes": [] + } + ] + }], + "defPermissions": [ + { + "name": "ohos.permission.REQUIRE_FORM", + "grantMode": "system_grant", + "label": "$string:entry_MainAbility", + "description": "REQUIRE_FORM permission in detail" + } + ], + "reqPermissions": [ + { + "name": "ohos.permission.REQUIRE_FORM", + "reason": "fmsStressTest100", + "usedScene": { + "ability": [ + ".MainAbility" + ], + "when": "always" + } + } + ], + "js": [ + { + "name": "formDemo", + "pages": [ + "pages/index/index" + ], + "type": "form" + } + ] + } +} \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostCommonA/include/form_ability_commona.h b/test/resource/formsystemtestability/fmsSystemTestHostCommonA/include/form_ability_commona.h new file mode 100644 index 0000000000..f53bc0f273 --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostCommonA/include/form_ability_commona.h @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _FORM_ABILITY_COMMONA_H_ +#define _FORM_ABILITY_COMMONA_H_ +#include "ability_loader.h" +#include "common_event.h" +#include "common_event_manager.h" + +namespace OHOS { +namespace AppExecFwk { +class FormEventSubscriberForCommonA; +class FormAbilityCommonA : public Ability { +public: + ~FormAbilityCommonA(); + void SubscribeEvent(); + void handleEvent(std::string action, std::string data); + + void FMS_acquireForm(std::string data); + void Clear(std::string data); + std::shared_ptr subscriber_; + + class AcquireFormCallback : public FormCallback { + public: + AcquireFormCallback(std::string name, int code):caseName_(name), code_(code) + { + } + virtual ~AcquireFormCallback() = default; + void OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnFormUninstall(const int64_t formId) const override; + + std::string caseName_ = ""; + int code_ = 0; + }; +protected: + virtual void Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) override; + virtual void OnStart(const Want &want) override; + virtual void OnStop() override; + virtual void OnActive() override; + virtual void OnInactive() override; + virtual void OnBackground() override; + + + using FormFunc = void (FormAbilityCommonA::*)(std::string data); + std::map memberFuncMap_; + std::map calledFuncMap_; + std::shared_ptr callback_; +}; + +class FormEventSubscriberForCommonA : public EventFwk::CommonEventSubscriber { +public: + FormEventSubscriberForCommonA(const EventFwk::CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp) + { + ability_ = nullptr; + } + ~FormEventSubscriberForCommonA() + { + ability_ = nullptr; + } + virtual void OnReceiveEvent(const EventFwk::CommonEventData &data) override; + void KitTerminateAbility(); + + FormAbilityCommonA *ability_; +}; +} // namespace AppExecFwk +} // namespace OHOS +#endif // _FORM_ABILITY_COMMONA_H_ \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostCommonA/src/form_ability_commona.cpp b/test/resource/formsystemtestability/fmsSystemTestHostCommonA/src/form_ability_commona.cpp new file mode 100644 index 0000000000..b19a7a203f --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostCommonA/src/form_ability_commona.cpp @@ -0,0 +1,188 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "app_log_wrapper.h" +#include "form_ability_commona.h" +#include +#include +#include +#include "form_test_utils.h" +#include "form_st_common_info.h" + +namespace { +using namespace OHOS::AAFwk; +using namespace OHOS::EventFwk; +} + +namespace OHOS { +namespace AppExecFwk { +std::vector eventList = { + FORM_EVENT_REQ_ONE_NORMAL_FORM, +}; +void FormAbilityCommonA::AcquireFormCallback::OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called[%{public}s]", __func__, std::to_string(formJsInfo.formId).c_str()); + //FormTestUtils::PublishEvent(this->caseName_, this->code_, std::to_string(formJsInfo.formId)); +} +void FormAbilityCommonA::AcquireFormCallback::OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called", __func__); + //FormTestUtils::PublishEvent(this->caseName_, this->code_ + 1, formJsInfo.formData); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ONE_NORMAL_FORM, 100, std::to_string(formJsInfo.formId)); +} + +void FormAbilityCommonA::AcquireFormCallback::OnFormUninstall(const int64_t formId) const +{ + APP_LOGI("%{public}s called", __func__); +} + +//Create one form(temp/normal) +void FormAbilityCommonA::FMS_acquireForm(std::string data) +{ + APP_LOGI("%{public}s called, data: %{public}s", __func__, data.c_str()); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ONE_NORMAL_FORM, 100); + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + if(data == "true") { + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_TRUE); + } else { + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + } + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[form_ability_commonA]AcquireForm end"); + } else { + APP_LOGE("[form_ability_commonA]AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ONE_NORMAL_FORM, 100, ""); + } +} + +FormAbilityCommonA::~FormAbilityCommonA() +{ + CommonEventManager::UnSubscribeCommonEvent(subscriber_); +} +void FormAbilityCommonA::OnStart(const Want &want) +{ + APP_LOGI("FormAbilityCommonA::onStart"); + Ability::OnStart(want); +} +void FormAbilityCommonA::OnActive() +{ + APP_LOGI("FormAbilityCommonA::OnActive"); + Ability::OnActive(); + std::string eventData = GetAbilityName() + FORM_ABILITY_STATE_ONACTIVE; + FormTestUtils::PublishEvent(FORM_EVENT_ABILITY_ONACTIVED, 0, eventData); +} + +void FormAbilityCommonA::OnStop() +{ + APP_LOGI("FormAbilityCommonA::OnStop"); + + Ability::OnStop(); +} +void FormAbilityCommonA::OnInactive() +{ + APP_LOGI("FormAbilityCommonA::OnInactive"); + + Ability::OnInactive(); +} +void FormAbilityCommonA::OnBackground() +{ + APP_LOGI("FormAbilityCommonA::OnBackground"); + + Ability::OnBackground(); +} +void FormAbilityCommonA::SubscribeEvent() +{ + APP_LOGI("FormAbilityCommonA::SubscribeEvent"); + MatchingSkills matchingSkills; + for (const auto &e : eventList) { + matchingSkills.AddEvent(e); + } + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + subscribeInfo.SetPriority(1); + subscriber_ = std::make_shared(subscribeInfo); + subscriber_->ability_ = this; + CommonEventManager::SubscribeCommonEvent(subscriber_); +} + +// KitTest End +void FormAbilityCommonA::Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) +{ + APP_LOGI("FormAbilityCommonA::Init"); + Ability::Init(abilityInfo, application, handler, token); + memberFuncMap_[FORM_EVENT_REQ_ONE_NORMAL_FORM] = &FormAbilityCommonA::FMS_acquireForm; + SubscribeEvent(); +} + +void FormAbilityCommonA::handleEvent(std::string action, std::string data) +{ + APP_LOGI("%{public}s called", __func__); + if(calledFuncMap_.find(action) != calledFuncMap_.end()) { + return; + } + calledFuncMap_.emplace(action, 0); + auto itFunc = memberFuncMap_.find(action); + if (itFunc != memberFuncMap_.end()) { + auto memberFunc = itFunc->second; + if (memberFunc != nullptr) { + return (this->*memberFunc)(data); + } + } +} + +void FormAbilityCommonA::Clear(std::string data) +{ + bool bResult = DeleteForm(atoll(data.c_str())); + if(bResult) { + APP_LOGI("[FormAbilityCommonA] Clear end"); + } else { + APP_LOGE("[FormAbilityCommonA] Clear error"); + } +} + +void FormEventSubscriberForCommonA::OnReceiveEvent(const CommonEventData &data) +{ + APP_LOGI("FormEventSubscriberForCommonA::OnReceiveEvent:event=%{public}s", data.GetWant().GetAction().c_str()); + APP_LOGI("KitTestEventSubscriber::OnReceiveEvent:data=%{public}s", data.GetData().c_str()); + APP_LOGI("FormEventSubscriberForCommonA::OnReceiveEvent:code=%{public}d", data.GetCode()); + //clear + if (data.GetCode() == 110) { + ability_->Clear(data.GetData()); + CommonEventManager::UnSubscribeCommonEvent(ability_->subscriber_); + } else { + auto eventName = data.GetWant().GetAction(); + ability_->handleEvent(eventName, data.GetData()); + } +} + +void FormEventSubscriberForCommonA::KitTerminateAbility() +{ + if (ability_ != nullptr) { + ability_->TerminateAbility(); + } +} + +REGISTER_AA(FormAbilityCommonA) +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNoPerm/BUILD.gn b/test/resource/formsystemtestability/fmsSystemTestHostNoPerm/BUILD.gn new file mode 100755 index 0000000000..bc1f36c5a3 --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNoPerm/BUILD.gn @@ -0,0 +1,70 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import("//build/ohos.gni") +import("//foundation/appexecfwk/standard/appexecfwk.gni") + +config("fmsSystemTestHostNoPermConfig") { + visibility = [ ":*" ] + include_dirs = [ + "include", + "../tool/include", + "${appexecfwk_path}/test/systemtest/common/fms/common/include", + "${aafwk_path}/interfaces/innerkits/ability_manager/include", + "${aafwk_path}/interfaces/innerkits/want/include/ohos/aafwk/content", + "${aafwk_path}/services/abilitymgr/include", + "${appexecfwk_path}/common/log/include", + "${appexecfwk_path}/interfaces/innerkits/libeventhandler/include", + "${appexecfwk_path}/kits/appkit/native/app", + "${appexecfwk_path}/services/bundlemgr/include", + "//foundation/distributedschedule/dmsfwk/services/dtbschedmgr/include", + "//utils/system/safwk/native/include", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core/include/appmgr", + "//third_party/jsoncpp/include", + ] + defines = [ + "APP_LOG_TAG = \"formManagerSystemTest\"", + "LOG_DOMAIN = 0xD002666", + ] +} +ohos_shared_library("fmsSystemTestHostNoPerm") { + sources = [ + "../tool/src/form_test_utils.cpp", + "src/form_ability_no_perm.cpp", + ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + configs = [ ":fmsSystemTestHostNoPermConfig" ] + deps = [ + "${aafwk_path}/frameworks/kits/ability/native:abilitykit_native", + "${aafwk_path}/interfaces/innerkits/base:base", + "${aafwk_path}/interfaces/innerkits/want:want", + "${appexecfwk_path}/common:libappexecfwk_common", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core:appexecfwk_core", + "${appexecfwk_path}/kits:appkit_native", + "${appexecfwk_path}/services/bundlemgr:libbms", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//third_party/jsoncpp:jsoncpp", + "//utils/native/base:utilsbase", + ] + external_deps = [ + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] + subsystem_name = "formsystemtestability" +} diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNoPerm/config.json b/test/resource/formsystemtestability/fmsSystemTestHostNoPerm/config.json new file mode 100644 index 0000000000..662ab9e31a --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNoPerm/config.json @@ -0,0 +1,60 @@ +{ + "app":{ + "bundleName": "com.ohos.form.manager.nopermission", + "vendor": "ix", + "version": { + "code": 1, + "name": "1.0" + }, + "apiVersion": { + "compatible": 3, + "target": 3 + } + }, + "deviceConfig": { + "default": { + } + }, + "module": { + "package":"com.ohos.form.manager.nopermission.FormAbility", + "name":"FormAbility", + "deviceType": [ + "phone" + ], + "distro": { + "deliveryWithInstall": true, + "moduleName": "FormAbility", + "moduleType": "entry" + }, + "abilities": [{ + "name": "FormAbilityNoPerm", + "icon": "$media:snowball", + "srcLanguage": "c++", + "label": "Form Ability A", + "launchType": "standard", + "orientation": "unspecified", + "type": "page", + "visible": true, + "skills": [ + { + "actions": [ + "ohos.aafwk.content.Want.ACTION_HOME" + ], + "entities": [ + "ohos.aafwk.content.Want.ENTITY_HOME" + ], + "attributes": [] + } + ] + }], + "js": [ + { + "name": "formDemo", + "pages": [ + "pages/index/index" + ], + "type": "form" + } + ] + } +} \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNoPerm/include/form_ability_no_perm.h b/test/resource/formsystemtestability/fmsSystemTestHostNoPerm/include/form_ability_no_perm.h new file mode 100644 index 0000000000..8694e2d20c --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNoPerm/include/form_ability_no_perm.h @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _FORM_ABILITY_A_H_ +#define _FORM_ABILITY_A_H_ +#include "ability_loader.h" +#include "common_event.h" +#include "common_event_manager.h" + +namespace OHOS { +namespace AppExecFwk { +class FormEventSubscriber; +class FormAbilityNoPerm : public Ability { +public: + void SubscribeEvent(const std::vector &eventList); + void handleEvent(std::string action); + + void FMS_acquireForm_0200(); + void FMS_deleteForm_0200(); + void FMS_releaseForm_0200(); + + std::shared_ptr subscriber_; + + class AcquireFormCallback : public FormCallback { + public: + AcquireFormCallback(std::string name):caseName_(name) + { + } + virtual ~AcquireFormCallback() = default; + void OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnFormUninstall(const int64_t formId) const override; + + std::string caseName_; + }; +protected: + virtual void Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) override; + virtual void OnStart(const Want &want) override; + virtual void OnStop() override; + virtual void OnActive() override; + virtual void OnInactive() override; + virtual void OnBackground() override; +private: + void Clear(); + + using FormFunc = void (FormAbilityNoPerm::*)(); + std::map memberFuncMap_; + +}; + +class FormEventSubscriber : public EventFwk::CommonEventSubscriber { +public: + FormEventSubscriber(const EventFwk::CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp) + { + ability_ = nullptr; + } + ~FormEventSubscriber() + { + ability_ = nullptr; + } + virtual void OnReceiveEvent(const EventFwk::CommonEventData &data) override; + void KitTerminateAbility(); + + FormAbilityNoPerm *ability_; +}; +} // namespace AppExecFwk +} // namespace OHOS +#endif // _FORM_ABILITY_A_H_ \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNoPerm/src/form_ability_no_perm.cpp b/test/resource/formsystemtestability/fmsSystemTestHostNoPerm/src/form_ability_no_perm.cpp new file mode 100644 index 0000000000..0c42252b42 --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNoPerm/src/form_ability_no_perm.cpp @@ -0,0 +1,186 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "app_log_wrapper.h" +#include "form_ability_no_perm.h" +#include +#include +#include +#include "form_test_utils.h" +#include "form_st_common_info.h" + +namespace { +using namespace OHOS::AAFwk; +using namespace OHOS::EventFwk; +} + +namespace OHOS { +namespace AppExecFwk { +void FormAbilityNoPerm::AcquireFormCallback::OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called", __func__); +} +void FormAbilityNoPerm::AcquireFormCallback::OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called", __func__); + +} +void FormAbilityNoPerm::AcquireFormCallback::OnFormUninstall(const int64_t formId) const +{ + APP_LOGI("%{public}s called", __func__); +} + +void FormAbilityNoPerm::FMS_acquireForm_0200() +{ + std::shared_ptr callback = std::make_shared("FMS_acquireForm_0200"); + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_0200, 200, "false"); + } +} + +void FormAbilityNoPerm::FMS_deleteForm_0200() +{ + int64_t formId = 1; + bool bResult = DeleteForm(formId); + if(bResult) { + APP_LOGI("[FMS_deleteForm_0200] end"); + } else { + APP_LOGE("[FMS_deleteForm_0200] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0200, 200, "false"); + } +} + +void FormAbilityNoPerm::FMS_releaseForm_0200() +{ + int64_t formId = 1; + bool isReleaseCache = true; + bool bResult = ReleaseForm(formId, isReleaseCache); + if(bResult) { + APP_LOGI("[FMS_releaseForm_0200] end"); + } else { + APP_LOGE("[FMS_releaseForm_0200] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0200, 200, "false"); + } +} + + +void FormAbilityNoPerm::OnStart(const Want &want) +{ + APP_LOGI("FormAbilityNoPerm::onStart"); + Ability::OnStart(want); + + std::vector eventList = { + FORM_EVENT_REQ_ACQUIRE_FORM_0200, + FORM_EVENT_REQ_DELETE_FORM_0200, + FORM_EVENT_REQ_RELEASE_FORM_0200, + }; + SubscribeEvent(eventList); +} +void FormAbilityNoPerm::OnActive() +{ + APP_LOGI("FormAbilityNoPerm::OnActive"); + Ability::OnActive(); + std::string eventData = GetAbilityName() + FORM_ABILITY_STATE_ONACTIVE; + FormTestUtils::PublishEvent(FORM_EVENT_ABILITY_ONACTIVED, 0, eventData); +} + +void FormAbilityNoPerm::OnStop() +{ + APP_LOGI("FormAbilityNoPerm::OnStop"); + + Ability::OnStop(); +} +void FormAbilityNoPerm::OnInactive() +{ + APP_LOGI("FormAbilityNoPerm::OnInactive"); + + Ability::OnInactive(); +} +void FormAbilityNoPerm::OnBackground() +{ + APP_LOGI("FormAbilityNoPerm::OnBackground"); + + Ability::OnBackground(); +} +void FormAbilityNoPerm::SubscribeEvent(const std::vector &eventList) +{ + MatchingSkills matchingSkills; + for (const auto &e : eventList) { + matchingSkills.AddEvent(e); + } + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + subscribeInfo.SetPriority(1); + subscriber_ = std::make_shared(subscribeInfo); + subscriber_->ability_ = this; + CommonEventManager::SubscribeCommonEvent(subscriber_); +} + +// KitTest End +void FormAbilityNoPerm::Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) +{ + APP_LOGI("FormAbilityNoPerm::Init"); + Ability::Init(abilityInfo, application, handler, token); + + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_0200] = &FormAbilityNoPerm::FMS_acquireForm_0200; + memberFuncMap_[FORM_EVENT_REQ_DELETE_FORM_0200] = &FormAbilityNoPerm::FMS_deleteForm_0200; + memberFuncMap_[FORM_EVENT_REQ_RELEASE_FORM_0200] = &FormAbilityNoPerm::FMS_releaseForm_0200; +} + +void FormAbilityNoPerm::handleEvent(std::string action) +{ + auto itFunc = memberFuncMap_.find(action); + if (itFunc != memberFuncMap_.end()) { + auto memberFunc = itFunc->second; + if (memberFunc != nullptr) { + return (this->*memberFunc)(); + } + } +} + +void FormAbilityNoPerm::Clear() +{ +} + +void FormEventSubscriber::OnReceiveEvent(const CommonEventData &data) +{ + APP_LOGI("FormEventSubscriber::OnReceiveEvent:event=%{public}s", data.GetWant().GetAction().c_str()); + APP_LOGI("FormEventSubscriber::OnReceiveEvent:code=%{public}d", data.GetCode()); + auto eventName = data.GetWant().GetAction(); + ability_->handleEvent(eventName); +} + +void FormEventSubscriber::KitTerminateAbility() +{ + if (ability_ != nullptr) { + ability_->TerminateAbility(); + } +} + +REGISTER_AA(FormAbilityNoPerm) +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNormal/BUILD.gn b/test/resource/formsystemtestability/fmsSystemTestHostNormal/BUILD.gn new file mode 100755 index 0000000000..869b06e2be --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNormal/BUILD.gn @@ -0,0 +1,72 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import("//build/ohos.gni") +import("//foundation/appexecfwk/standard/appexecfwk.gni") + +config("fmsSystemTestHostNormalConfig") { + visibility = [ ":*" ] + include_dirs = [ + "include", + "../tool/include", + "${appexecfwk_path}/test/systemtest/common/fms/common/include", + "${aafwk_path}/interfaces/innerkits/ability_manager/include", + "${aafwk_path}/interfaces/innerkits/want/include/ohos/aafwk/content", + "${aafwk_path}/services/abilitymgr/include", + "${appexecfwk_path}/common/log/include", + "${appexecfwk_path}/interfaces/innerkits/libeventhandler/include", + "${appexecfwk_path}/kits/appkit/native/app", + "${appexecfwk_path}/services/bundlemgr/include", + "//foundation/distributedschedule/dmsfwk/services/dtbschedmgr/include", + "//utils/system/safwk/native/include", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core/include/appmgr", + "//third_party/jsoncpp/include", + ] + defines = [ + "APP_LOG_TAG = \"formManagerSystemTest\"", + "LOG_DOMAIN = 0xD002666", + ] +} +ohos_shared_library("fmsSystemTestHostNormal") { + sources = [ + "../tool/src/form_test_utils.cpp", + "src/form_ability_a.cpp", + "src/form_ability_deleteform.cpp", + "src/form_ability_releaseform.cpp", + ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + configs = [ ":fmsSystemTestHostNormalConfig" ] + deps = [ + "${aafwk_path}/frameworks/kits/ability/native:abilitykit_native", + "${aafwk_path}/interfaces/innerkits/base:base", + "${aafwk_path}/interfaces/innerkits/want:want", + "${appexecfwk_path}/common:libappexecfwk_common", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core:appexecfwk_core", + "${appexecfwk_path}/kits:appkit_native", + "${appexecfwk_path}/services/bundlemgr:libbms", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//third_party/jsoncpp:jsoncpp", + "//utils/native/base:utilsbase", + ] + external_deps = [ + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] + subsystem_name = "formsystemtestability" +} diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNormal/config.json b/test/resource/formsystemtestability/fmsSystemTestHostNormal/config.json new file mode 100644 index 0000000000..e3ec3c806a --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNormal/config.json @@ -0,0 +1,122 @@ +{ + "app":{ + "bundleName": "com.ohos.form.manager.normal", + "vendor": "ix", + "version": { + "code": 1, + "name": "1.0" + }, + "apiVersion": { + "compatible": 3, + "target": 3 + } + }, + "deviceConfig": { + "default": { + } + }, + "module": { + "package":"com.ohos.form.manager.normal.FormAbility", + "name":"FormAbility", + "deviceType": [ + "phone" + ], + "distro": { + "deliveryWithInstall": true, + "moduleName": "FormAbility", + "moduleType": "entry" + }, + "abilities": [{ + "name": "FormAbilityA", + "icon": "$media:snowball", + "srcLanguage": "c++", + "label": "Form Ability A", + "launchType": "standard", + "orientation": "unspecified", + "type": "page", + "visible": true, + "skills": [ + { + "actions": [ + "ohos.aafwk.content.Want.ACTION_HOME" + ], + "entities": [ + "ohos.aafwk.content.Want.ENTITY_HOME" + ], + "attributes": [] + } + ] + }, + { + "name": "FormAbilityDeleteForm", + "icon": "$media:snowball", + "srcLanguage": "c++", + "label": "Form Ability A", + "launchType": "standard", + "orientation": "unspecified", + "type": "page", + "visible": true, + "skills": [ + { + "actions": [ + "ohos.aafwk.content.Want.ACTION_HOME" + ], + "entities": [ + "ohos.aafwk.content.Want.ENTITY_HOME" + ], + "attributes": [] + } + ] + }, + { + "name": "FormAbilityReleaseForm", + "icon": "$media:snowball", + "srcLanguage": "c++", + "label": "Form Ability A", + "launchType": "standard", + "orientation": "unspecified", + "type": "page", + "visible": true, + "skills": [ + { + "actions": [ + "ohos.aafwk.content.Want.ACTION_HOME" + ], + "entities": [ + "ohos.aafwk.content.Want.ENTITY_HOME" + ], + "attributes": [] + } + ] + }], + "defPermissions": [ + { + "name": "ohos.permission.REQUIRE_FORM", + "grantMode": "system_grant", + "label": "$string:entry_MainAbility", + "description": "REQUIRE_FORM permission in detail" + } + ], + "reqPermissions": [ + { + "name": "ohos.permission.REQUIRE_FORM", + "reason": "fmsStressTest100", + "usedScene": { + "ability": [ + ".MainAbility" + ], + "when": "always" + } + } + ], + "js": [ + { + "name": "formDemo", + "pages": [ + "pages/index/index" + ], + "type": "form" + } + ] + } +} \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNormal/include/form_ability_a.h b/test/resource/formsystemtestability/fmsSystemTestHostNormal/include/form_ability_a.h new file mode 100644 index 0000000000..18706d53cb --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNormal/include/form_ability_a.h @@ -0,0 +1,115 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _FORM_ABILITY_A_H_ +#define _FORM_ABILITY_A_H_ +#include "ability_loader.h" +#include "common_event.h" +#include "common_event_manager.h" + +namespace OHOS { +namespace AppExecFwk { +class FormEventSubscriber; +class FormAbilityA : public Ability { +public: + ~FormAbilityA(); + void SubscribeEvent(); + void handleEvent(std::string action, std::string data); + + void FMS_deleteFormCommon(int64_t formId); + + void FMS_acquireForm_0300(std::string data); + void FMS_acquireForm_0400(std::string data); + void FMS_acquireForm_0500(std::string data); + void FMS_acquireForm_0600(std::string data); + void FMS_acquireForm_0700(std::string data); + void FMS_acquireForm_1000(std::string data); + void FMS_acquireForm_1100(std::string data); + void FMS_acquireForm_1200(std::string data); + void FMS_acquireForm_1500_1(std::string data); + void FMS_acquireForm_1600(std::string data); + void FMS_acquireForm_1600_1(std::string data); + void FMS_acquireForm_1800(std::string data); + void FMS_acquireForm_1800_1(std::string data); + void FMS_acquireForm_1900(std::string data); + void FMS_acquireForm_2100(std::string data); + void FMS_acquireForm_2200(std::string data); + void FMS_acquireForm_2300(std::string data); + void FMS_acquireForm_2400(std::string data); + void FMS_acquireForm_2500(std::string data); + void FMS_acquireForm_2600(std::string data); + void FMS_acquireForm_2600_1(std::string data); + void FMS_acquireForm_2700(std::string data); + void FMS_acquireForm_2800(std::string data); + void FMS_acquireForm_2900(std::string data); + void FMS_acquireForm_3000(std::string data); + void FMS_acquireForm_3100(std::string data); + void FMS_acquireForm_3200(std::string data); + void FMS_acquireForm_3300(std::string data); + void FMS_acquireForm_3400(std::string data); + void FMS_acquireForm_3500(std::string data); + + std::shared_ptr subscriber_; + + class AcquireFormCallback : public FormCallback { + public: + AcquireFormCallback(std::string name, int code):caseName_(name), code_(code) + { + } + virtual ~AcquireFormCallback() = default; + void OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnFormUninstall(const int64_t formId) const override; + + std::string caseName_ = ""; + int code_ = 0; + FormAbilityA *ability_; + }; +protected: + virtual void Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) override; + virtual void OnStart(const Want &want) override; + virtual void OnStop() override; + virtual void OnActive() override; + virtual void OnInactive() override; + virtual void OnBackground() override; +private: + void Clear(); + + using FormFunc = void (FormAbilityA::*)(std::string data); + std::map memberFuncMap_; + std::map calledFuncMap_; + std::shared_ptr callback_; +}; + +class FormEventSubscriber : public EventFwk::CommonEventSubscriber { +public: + FormEventSubscriber(const EventFwk::CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp) + { + ability_ = nullptr; + } + ~FormEventSubscriber() + { + ability_ = nullptr; + } + virtual void OnReceiveEvent(const EventFwk::CommonEventData &data) override; + void KitTerminateAbility(); + + FormAbilityA *ability_; +}; +} // namespace AppExecFwk +} // namespace OHOS +#endif // _FORM_ABILITY_A_H_ \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNormal/include/form_ability_deleteform.h b/test/resource/formsystemtestability/fmsSystemTestHostNormal/include/form_ability_deleteform.h new file mode 100644 index 0000000000..b59f9d8444 --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNormal/include/form_ability_deleteform.h @@ -0,0 +1,107 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _FORM_ABILITY_DELETEFORM_H_ +#define _FORM_ABILITY_DELETEFORM_H_ +#include "ability_loader.h" +#include "common_event.h" +#include "common_event_manager.h" + +namespace OHOS { +namespace AppExecFwk { +class FormEventSubscriberForDeleteForm; +class FormAbilityDeleteForm : public Ability { +public: + void SubscribeEvent(const std::vector &eventList); + void handleEvent(std::string action, std::string data); + void FMS_deleteForm_common(int64_t formId, std::string caseName, std::string lastFormId); + void FMS_deleteForm_0300(std::string data); + void FMS_deleteForm_0400(std::string data); + void FMS_deleteForm_0500(std::string data); + void FMS_deleteForm_0600(std::string data); + void FMS_deleteForm_0700(std::string data); + void FMS_deleteForm_0800(std::string data); + void FMS_deleteForm_0900(std::string data); + void FMS_deleteForm_1000(std::string data); + void FMS_deleteForm_1100(std::string data); + void FMS_deleteForm_1200(std::string data); + void FMS_deleteForm_1400(std::string data); + void FMS_deleteForm_1500(std::string data); + void FMS_deleteForm_1600(std::string data); + void FMS_deleteForm_1700(std::string data); + + std::shared_ptr subscriber_; + class AcquireFormCallback : public FormCallback { + public: + AcquireFormCallback(std::string name, std::string id):caseName_(name), lastformId_(id) + { + } + virtual ~AcquireFormCallback() = default; + void OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnFormUninstall(const int64_t formId) const override; + FormAbilityDeleteForm *ability_; + std::string caseName_; + std::string lastformId_; + }; +protected: + virtual void Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) override; + virtual void OnStart(const Want &want) override; + virtual void OnStop() override; + virtual void OnActive() override; + virtual void OnInactive() override; + virtual void OnBackground() override; +private: + void Clear(std::string case_id, int64_t form_id); + void DeleteForm_0300(int64_t form_id); + void DeleteForm_0400(int64_t form_id); + void DeleteForm_0500(int64_t form_id); + void DeleteForm_0600(int64_t form_id); + void DeleteForm_0700(int64_t form_id, std::string lastFormId); + void DeleteForm_0800(int64_t form_id); + void DeleteForm_0900(int64_t form_id); + void DeleteForm_1000(int64_t form_id); + void DeleteForm_1100(int64_t form_id, std::string lastFormId); + void DeleteForm_1200(int64_t form_id); + void DeleteForm_1400(int64_t form_id); + void DeleteForm_1500(int64_t form_id); + void DeleteForm_1600(int64_t form_id); + void DeleteForm_1700(int64_t form_id); + + using FormFunc = void (FormAbilityDeleteForm::*)(std::string data); + std::map memberFuncMap_; + std::shared_ptr callback_; + +}; +class FormEventSubscriberForDeleteForm : public EventFwk::CommonEventSubscriber { +public: + FormEventSubscriberForDeleteForm(const EventFwk::CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp) + { + ability_ = nullptr; + } + ~FormEventSubscriberForDeleteForm() + { + ability_ = nullptr; + } + virtual void OnReceiveEvent(const EventFwk::CommonEventData &data) override; + void KitTerminateAbility(); + + FormAbilityDeleteForm *ability_; +}; +} // namespace AppExecFwk +} // namespace OHOS +#endif // _FORM_ABILITY_DELETEFORM_H_ \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNormal/include/form_ability_releaseform.h b/test/resource/formsystemtestability/fmsSystemTestHostNormal/include/form_ability_releaseform.h new file mode 100644 index 0000000000..4cb3004a9a --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNormal/include/form_ability_releaseform.h @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _FORM_ABILITY_RELEASEFORM_H_ +#define _FORM_ABILITY_RELEASEFORM_H_ +#include "ability_loader.h" +#include "common_event.h" +#include "common_event_manager.h" + +namespace OHOS { +namespace AppExecFwk { +class FormEventSubscriberForReleaseForm; +class FormAbilityReleaseForm : public Ability { +public: + void SubscribeEvent(const std::vector &eventList); + void handleEvent(std::string action, std::string data); + void FMS_releaseForm_common(int64_t formId, std::string caseName, std::string lastFormId); + void FMS_releaseForm_0300(std::string data); + void FMS_releaseForm_0400(std::string data); + void FMS_releaseForm_0500(std::string data); + void FMS_releaseForm_0600(std::string data); + void FMS_releaseForm_0700(std::string data); + void FMS_releaseForm_0800(std::string data); + void FMS_releaseForm_0900(std::string data); + void FMS_releaseForm_1000(std::string data); + void FMS_releaseForm_1100(std::string data); + void FMS_releaseForm_1200(std::string data); + void FMS_releaseForm_1300(std::string data); + void FMS_releaseForm_1400(std::string data); + + std::shared_ptr subscriber_; + + class AcquireFormCallback : public FormCallback { + public: + AcquireFormCallback(std::string name, std::string id):caseName_(name), lastformId_(id) + { + } + virtual ~AcquireFormCallback() = default; + void OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnFormUninstall(const int64_t formId) const override; + FormAbilityReleaseForm *ability_; + std::string caseName_; + std::string lastformId_; + }; +protected: + virtual void Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) override; + virtual void OnStart(const Want &want) override; + virtual void OnStop() override; + virtual void OnActive() override; + virtual void OnInactive() override; + virtual void OnBackground() override; +private: + void Clear(std::string case_id, int64_t form_id); + void ReleaseForm_0300(int64_t form_id); + void ReleaseForm_0400(int64_t form_id); + void ReleaseForm_0500(int64_t form_id); + void ReleaseForm_0600(int64_t form_id); + void ReleaseForm_0700(int64_t form_id, std::string lastFormId); + void ReleaseForm_0800(int64_t form_id, std::string lastFormId); + void ReleaseForm_0900(int64_t form_id); + void ReleaseForm_1000(int64_t form_id, std::string lastFormId); + void ReleaseForm_1100(int64_t form_id, std::string lastFormId); + void ReleaseForm_1200(int64_t form_id); + void ReleaseForm_1300(int64_t form_id, std::string lastFormId); + void ReleaseForm_1400(int64_t form_id); + + using FormFunc = void (FormAbilityReleaseForm::*)(std::string data); + std::map memberFuncMap_; + std::shared_ptr callback_; +}; +class FormEventSubscriberForReleaseForm : public EventFwk::CommonEventSubscriber { +public: + FormEventSubscriberForReleaseForm(const EventFwk::CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp) + { + ability_ = nullptr; + } + ~FormEventSubscriberForReleaseForm() + { + ability_ = nullptr; + } + virtual void OnReceiveEvent(const EventFwk::CommonEventData &data) override; + void KitTerminateAbility(); + + FormAbilityReleaseForm *ability_; +}; +} // namespace AppExecFwk +} // namespace OHOS +#endif // _FORM_ABILITY_RELEASEFORM_H_ \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNormal/src/form_ability_a.cpp b/test/resource/formsystemtestability/fmsSystemTestHostNormal/src/form_ability_a.cpp new file mode 100644 index 0000000000..af5d35bc3c --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNormal/src/form_ability_a.cpp @@ -0,0 +1,644 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "app_log_wrapper.h" +#include "form_ability_a.h" +#include +#include +#include +#include "form_test_utils.h" +#include "form_st_common_info.h" + +namespace { +using namespace OHOS::AAFwk; +using namespace OHOS::EventFwk; +} + +namespace OHOS { +namespace AppExecFwk { +std::vector eventList = { + FORM_EVENT_REQ_ACQUIRE_FORM_0300, FORM_EVENT_REQ_ACQUIRE_FORM_0400, FORM_EVENT_REQ_ACQUIRE_FORM_0500, + FORM_EVENT_REQ_ACQUIRE_FORM_0600, FORM_EVENT_REQ_ACQUIRE_FORM_0700, FORM_EVENT_REQ_ACQUIRE_FORM_1000, + FORM_EVENT_REQ_ACQUIRE_FORM_1100, FORM_EVENT_REQ_ACQUIRE_FORM_1200, FORM_EVENT_REQ_ACQUIRE_FORM_1500_1, + FORM_EVENT_REQ_ACQUIRE_FORM_1600, FORM_EVENT_REQ_ACQUIRE_FORM_1600_1, FORM_EVENT_REQ_ACQUIRE_FORM_1800, + FORM_EVENT_REQ_ACQUIRE_FORM_1800_1, FORM_EVENT_REQ_ACQUIRE_FORM_1900, + FORM_EVENT_REQ_ACQUIRE_FORM_2100, FORM_EVENT_REQ_ACQUIRE_FORM_2200, FORM_EVENT_REQ_ACQUIRE_FORM_2300, + FORM_EVENT_REQ_ACQUIRE_FORM_2500, FORM_EVENT_REQ_ACQUIRE_FORM_2600, FORM_EVENT_REQ_ACQUIRE_FORM_2600_1, + +}; +void FormAbilityA::AcquireFormCallback::OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called", __func__); + FormTestUtils::PublishEvent(this->caseName_, this->code_, std::to_string(formJsInfo.formId)); +} +void FormAbilityA::AcquireFormCallback::OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called", __func__); + FormTestUtils::PublishEvent(this->caseName_, this->code_ + 1, formJsInfo.formData); + + if (/*this->caseName_ == FORM_EVENT_RECV_ACQUIRE_FORM_1100 || */this->caseName_ == FORM_EVENT_RECV_ACQUIRE_FORM_1200 + || this->caseName_ == FORM_EVENT_RECV_ACQUIRE_FORM_1600|| this->caseName_ == FORM_EVENT_RECV_ACQUIRE_FORM_1600_1 + || this->caseName_ == FORM_EVENT_RECV_ACQUIRE_FORM_1800|| this->caseName_ == FORM_EVENT_RECV_ACQUIRE_FORM_1800_1 + || this->caseName_ == FORM_EVENT_RECV_ACQUIRE_FORM_1900) { + int64_t formId = formJsInfo.formId; + APP_LOGI("%{public}s, delete form, formId: %{public}lld", __func__, formId); + ability_->FMS_deleteFormCommon(formId); + } + +} + +void FormAbilityA::AcquireFormCallback::OnFormUninstall(const int64_t formId) const +{ + APP_LOGI("%{public}s called", __func__); +} +void FormAbilityA::FMS_deleteFormCommon(int64_t formId) +{ + APP_LOGI("%{public}s called, formId: %{public}lld", __func__, formId); + bool bResult = DeleteForm(formId); + sleep(1); + if(bResult) { + APP_LOGI("DeleteForm end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_COMMON, 999, "true"); + } else { + APP_LOGE("DeleteForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_COMMON, 999, "false"); + } +} +void FormAbilityA::FMS_acquireForm_0300(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_0300, 300); + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(-1, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_0300, 300, "false"); + } +} +void FormAbilityA::FMS_acquireForm_0400(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_0400, 400); + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, "com.form.bundlename99", FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_0400, 400, "false"); + } +} +void FormAbilityA::FMS_acquireForm_0500(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_0500, 500); + // Set Want info begin + std::string moduleName = "moduleName99"; + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, moduleName); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_0500, 500, "false"); + } +} +void FormAbilityA::FMS_acquireForm_0600(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_0600, 600); + // Set Want info begin + std::string formName = "formName999"; + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, formName); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_0600, 600, "false"); + } +} +void FormAbilityA::FMS_acquireForm_0700(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_0700, 700); + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, "abilityName9"); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_0700, 700, "false"); + } +} +void FormAbilityA::FMS_acquireForm_1000(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_1000, 1000); + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, 0); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_1000, 1000, "false"); + } +} +void FormAbilityA::FMS_acquireForm_1100(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_1100, 1100); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_1100, 1100, ""); + } +} +void FormAbilityA::FMS_acquireForm_1200(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_1200, 1200); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME2); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME2); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME2, FORM_PROVIDER_ABILITY_NAME2); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_1200, 1200, ""); + } +} + +void FormAbilityA::FMS_acquireForm_1500_1(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_1500_1, 1510); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_1500_1, 1510, ""); + } +} + +void FormAbilityA::FMS_acquireForm_1600(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_1600, 1600); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_1600, 1600, ""); + } +} +void FormAbilityA::FMS_acquireForm_1600_1(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_1600_1, 1610); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_TRUE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_1600_1, 1610, ""); + } +} +void FormAbilityA::FMS_acquireForm_1800(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_1800, 1800); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_1800, 1800, ""); + } +} +void FormAbilityA::FMS_acquireForm_1800_1(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_1800_1, 1810); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_TRUE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_1800_1, 1810, ""); + } +} +void FormAbilityA::FMS_acquireForm_1900(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_1900, 1900); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_TRUE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_1900, 1900, ""); + } +} +void FormAbilityA::FMS_acquireForm_2100(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_2100, 2100); + callback->ability_ = this; + // Set Want info begin + int64_t formId = std::stoll(data); + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_TRUE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(formId, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_2100, 2100, "false"); + } +} +void FormAbilityA::FMS_acquireForm_2200(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_2200, 2200); + + // Set Want info end + bool bResult = CastTempForm(-1); + if(bResult) { + APP_LOGI("CastTempForm end"); + } else { + APP_LOGE("CastTempForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_2200, 2200, "false"); + } +} +void FormAbilityA::FMS_acquireForm_2300(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_2300, 2300); + + // Set Want info end + bool bResult = CastTempForm(0); + if(bResult) { + APP_LOGI("CastTempForm end"); + } else { + APP_LOGE("CastTempForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_2300, 2300, "false"); + } +} +void FormAbilityA::FMS_acquireForm_2400(std::string data) +{ +} +void FormAbilityA::FMS_acquireForm_2500(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_2500, 2500); + + // Set Want info end + bool bResult = CastTempForm(1234); + if(bResult) { + APP_LOGI("CastTempForm end"); + } else { + APP_LOGE("CastTempForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_2500, 2500, "false"); + } +} +void FormAbilityA::FMS_acquireForm_2600_1(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_2600_1, 2610); + + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_TRUE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_2600_1, 2610, ""); + } +} + +void FormAbilityA::FMS_acquireForm_2600(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_2600, 2600); + callback->ability_ = this; + // Set Want info end + int64_t formId = std::stoll(data); + bool bResult = CastTempForm(formId); + if(bResult) { + APP_LOGI("CastTempForm end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_2600, 2600, "true"); + } else { + APP_LOGE("CastTempForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_2600, 2600, "false"); + } + + FMS_deleteFormCommon(formId); +} +void FormAbilityA::FMS_acquireForm_2700(std::string data) +{ +} +void FormAbilityA::FMS_acquireForm_2800(std::string data) +{ +} +void FormAbilityA::FMS_acquireForm_2900(std::string data) +{ +} +void FormAbilityA::FMS_acquireForm_3000(std::string data) +{ +} +void FormAbilityA::FMS_acquireForm_3100(std::string data) +{ +} +void FormAbilityA::FMS_acquireForm_3200(std::string data) +{ +} +void FormAbilityA::FMS_acquireForm_3300(std::string data) +{ +} +void FormAbilityA::FMS_acquireForm_3400(std::string data) +{ +} +void FormAbilityA::FMS_acquireForm_3500(std::string data) +{ +} + +FormAbilityA::~FormAbilityA() +{ + CommonEventManager::UnSubscribeCommonEvent(subscriber_); +} +void FormAbilityA::OnStart(const Want &want) +{ + APP_LOGI("FormAbilityA::onStart"); + Ability::OnStart(want); +} +void FormAbilityA::OnActive() +{ + APP_LOGI("FormAbilityA::OnActive"); + Ability::OnActive(); + std::string eventData = GetAbilityName() + FORM_ABILITY_STATE_ONACTIVE; + FormTestUtils::PublishEvent(FORM_EVENT_ABILITY_ONACTIVED, 0, eventData); +} + +void FormAbilityA::OnStop() +{ + APP_LOGI("FormAbilityA::OnStop"); + + Ability::OnStop(); +} +void FormAbilityA::OnInactive() +{ + APP_LOGI("FormAbilityA::OnInactive"); + + Ability::OnInactive(); +} +void FormAbilityA::OnBackground() +{ + APP_LOGI("FormAbilityA::OnBackground"); + + Ability::OnBackground(); +} +void FormAbilityA::SubscribeEvent() +{ + APP_LOGI("FormAbilityA::SubscribeEvent"); + MatchingSkills matchingSkills; + for (const auto &e : eventList) { + matchingSkills.AddEvent(e); + } + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + subscribeInfo.SetPriority(1); + subscriber_ = std::make_shared(subscribeInfo); + subscriber_->ability_ = this; + CommonEventManager::SubscribeCommonEvent(subscriber_); +} + +// KitTest End +void FormAbilityA::Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) +{ + APP_LOGI("FormAbilityA::Init"); + Ability::Init(abilityInfo, application, handler, token); + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_0300] = &FormAbilityA::FMS_acquireForm_0300; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_0400] = &FormAbilityA::FMS_acquireForm_0400; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_0500] = &FormAbilityA::FMS_acquireForm_0500; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_0600] = &FormAbilityA::FMS_acquireForm_0600; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_0700] = &FormAbilityA::FMS_acquireForm_0700; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_1000] = &FormAbilityA::FMS_acquireForm_1000; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_1100] = &FormAbilityA::FMS_acquireForm_1100; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_1200] = &FormAbilityA::FMS_acquireForm_1200; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_1500_1] = &FormAbilityA::FMS_acquireForm_1500_1; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_1600] = &FormAbilityA::FMS_acquireForm_1600; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_1600_1] = &FormAbilityA::FMS_acquireForm_1600_1; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_1800] = &FormAbilityA::FMS_acquireForm_1800; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_1800_1] = &FormAbilityA::FMS_acquireForm_1800_1; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_1900] = &FormAbilityA::FMS_acquireForm_1900; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_2100] = &FormAbilityA::FMS_acquireForm_2100; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_2200] = &FormAbilityA::FMS_acquireForm_2200; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_2300] = &FormAbilityA::FMS_acquireForm_2300; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_2500] = &FormAbilityA::FMS_acquireForm_2500; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_2600] = &FormAbilityA::FMS_acquireForm_2600; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_2600_1] = &FormAbilityA::FMS_acquireForm_2600_1; + SubscribeEvent(); +} + +void FormAbilityA::handleEvent(std::string action, std::string data) +{ + APP_LOGI("%{public}s called", __func__); + if(calledFuncMap_.find(action) != calledFuncMap_.end()) { + return; + } + calledFuncMap_.emplace(action, 0); + auto itFunc = memberFuncMap_.find(action); + if (itFunc != memberFuncMap_.end()) { + auto memberFunc = itFunc->second; + if (memberFunc != nullptr) { + return (this->*memberFunc)(data); + } + } +} + +void FormAbilityA::Clear() +{ +} + +void FormEventSubscriber::OnReceiveEvent(const CommonEventData &data) +{ + APP_LOGI("FormEventSubscriber::OnReceiveEvent:event=%{public}s", data.GetWant().GetAction().c_str()); + APP_LOGI("KitTestEventSubscriber::OnReceiveEvent:data=%{public}s", data.GetData().c_str()); + APP_LOGI("FormEventSubscriber::OnReceiveEvent:code=%{public}d", data.GetCode()); + auto eventName = data.GetWant().GetAction(); + ability_->handleEvent(eventName, data.GetData()); + + CommonEventManager::UnSubscribeCommonEvent(ability_->subscriber_); +} + +void FormEventSubscriber::KitTerminateAbility() +{ + if (ability_ != nullptr) { + ability_->TerminateAbility(); + } +} + +REGISTER_AA(FormAbilityA) +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNormal/src/form_ability_deleteform.cpp b/test/resource/formsystemtestability/fmsSystemTestHostNormal/src/form_ability_deleteform.cpp new file mode 100644 index 0000000000..798fbc126e --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNormal/src/form_ability_deleteform.cpp @@ -0,0 +1,540 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "app_log_wrapper.h" +#include +#include +#include +#include "form_ability_deleteform.h" +#include "form_test_utils.h" +#include "form_st_common_info.h" + +namespace { +using namespace OHOS::AAFwk; +using namespace OHOS::EventFwk; +} + +namespace OHOS { +namespace AppExecFwk { +void FormAbilityDeleteForm::AcquireFormCallback::OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called", __func__); + APP_LOGI("%{public}s receive formId:%{public}s", __func__, std::to_string(formJsInfo.formId).c_str()); + //FormTestUtils::PublishEvent(this->caseName_, 0, std::to_string(formJsInfo.formId)); + if (this->caseName_ == FORM_EVENT_RECV_DELETE_FORM_0600) { + //ability_->FMS_deleteForm_common(formJsInfo.formId, this->caseName_, this->lastformId_); + ability_->FMS_deleteForm_common(atoll(this->lastformId_.c_str()), this->caseName_, this->lastformId_); + } +} +void FormAbilityDeleteForm::AcquireFormCallback::OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called", __func__); + APP_LOGI("%{public}s receive formData:%{public}s", __func__, formJsInfo.formData.c_str()); + //FormTestUtils::PublishEvent(this->caseName_, 1, formJsInfo.formData); + if (this->caseName_ == FORM_EVENT_RECV_DELETE_FORM_0300 || this->caseName_ == FORM_EVENT_RECV_DELETE_FORM_0400 + || this->caseName_ == FORM_EVENT_RECV_DELETE_FORM_0700 || this->caseName_ == FORM_EVENT_RECV_DELETE_FORM_0800 + || this->caseName_ == FORM_EVENT_RECV_DELETE_FORM_0900 || this->caseName_ == FORM_EVENT_RECV_DELETE_FORM_1000 + || this->caseName_ == FORM_EVENT_RECV_DELETE_FORM_1100) { + ability_->FMS_deleteForm_common(formJsInfo.formId, this->caseName_, this->lastformId_); + } +} + +void FormAbilityDeleteForm::AcquireFormCallback::OnFormUninstall(const int64_t formId) const +{ + APP_LOGI("%{public}s called", __func__); +} + +void FormAbilityDeleteForm::FMS_deleteForm_common(int64_t formId, std::string caseName, std::string lastFormId) +{ + APP_LOGI("%{public}s called, formId: %{public}s, caseName:%{public}s, lastFormId:%{public}s", + __func__, std::to_string(formId), caseName.c_str(), lastFormId.c_str()); + if(caseName == FORM_EVENT_RECV_DELETE_FORM_0300) { + DeleteForm_0300(formId); + } else if (caseName == FORM_EVENT_RECV_DELETE_FORM_0400) { + DeleteForm_0400(formId); + } else if (caseName == FORM_EVENT_RECV_DELETE_FORM_0600) { + DeleteForm_0600(formId); + } else if (caseName == FORM_EVENT_RECV_DELETE_FORM_0700) { + DeleteForm_0700(formId, lastFormId); + } else if (caseName == FORM_EVENT_RECV_DELETE_FORM_0800) { + DeleteForm_0800(formId); + } else if (caseName == FORM_EVENT_RECV_DELETE_FORM_0900) { + DeleteForm_0900(formId); + } else if (caseName == FORM_EVENT_RECV_DELETE_FORM_1000) { + DeleteForm_1000(formId); + } else if (caseName == FORM_EVENT_RECV_DELETE_FORM_1100) { + DeleteForm_1100(formId, lastFormId); + } else { + return; + } +} + +void FormAbilityDeleteForm::FMS_deleteForm_0300(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_DELETE_FORM_0300, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_deleteForm_0300] AcquireForm ok."); + } else { + APP_LOGE("[FMS_deleteForm_0300] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0300, 300, ""); + } +} +void FormAbilityDeleteForm::FMS_deleteForm_0400(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_DELETE_FORM_0400, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_deleteForm_0400] AcquireForm ok."); + } else { + APP_LOGE("[FMS_deleteForm_0400] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0400, 400, ""); + } +} + +void FormAbilityDeleteForm::FMS_deleteForm_0500(std::string data) +{ + APP_LOGI("[FMS_deleteForm_0500] start[%{public}s]", data.c_str()); + bool bResult = DeleteForm(atoll(data.c_str())); + //Clear + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ONE_NORMAL_FORM, 110, data); + if(bResult) { + APP_LOGI("[FMS_deleteForm_0500] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0500, 500, "true"); + } else { + APP_LOGE("[FMS_deleteForm_0500] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0500, 500, "false"); + } +} + +void FormAbilityDeleteForm::FMS_deleteForm_0600(std::string data) +{ + APP_LOGI("[FMS_deleteForm_0600] start[%{public}s]", data.c_str()); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_DELETE_FORM_0600, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(atoll(data.c_str()), want, callback); + if(bResult) { + APP_LOGI("[FMS_deleteForm_0600] AcquireForm ok."); + } else { + APP_LOGE("[FMS_deleteForm_0600] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0600, 600, ""); + } +} + +void FormAbilityDeleteForm::FMS_deleteForm_0700(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_DELETE_FORM_0700, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_deleteForm_0700] AcquireForm ok."); + } else { + APP_LOGE("[FMS_deleteForm_0700] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0700, 700, ""); + } +} + +void FormAbilityDeleteForm::FMS_deleteForm_0800(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_DELETE_FORM_0800, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_deleteForm_0800] AcquireForm ok."); + } else { + APP_LOGE("[FMS_deleteForm_0800] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0800, 800, ""); + } +} +void FormAbilityDeleteForm::FMS_deleteForm_0900(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_DELETE_FORM_0900, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_deleteForm_0900] AcquireForm ok."); + } else { + APP_LOGE("[FMS_deleteForm_0900] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0900, 900, ""); + } +} + +void FormAbilityDeleteForm::FMS_deleteForm_1000(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_DELETE_FORM_1000, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_deleteForm_1000] AcquireForm ok."); + } else { + APP_LOGE("[FMS_deleteForm_1000] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_1000, 1000, ""); + } +} + +void FormAbilityDeleteForm::FMS_deleteForm_1100(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_DELETE_FORM_1100, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_TRUE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_deleteForm_1100] AcquireForm ok."); + } else { + APP_LOGE("[FMS_deleteForm_1100] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_1100, 1100, ""); + } +} + +void FormAbilityDeleteForm::FMS_deleteForm_1200(std::string data) +{} + +void FormAbilityDeleteForm::FMS_deleteForm_1400(std::string data) +{} + +void FormAbilityDeleteForm::FMS_deleteForm_1500(std::string data) +{} + +void FormAbilityDeleteForm::FMS_deleteForm_1600(std::string data) +{} + +void FormAbilityDeleteForm::FMS_deleteForm_1700(std::string data) +{} + + +void FormAbilityDeleteForm::DeleteForm_0300(int64_t form_id) +{ + bool bResult = DeleteForm(-1); + Clear("FMS_deleteForm_0300", form_id); + if(bResult) { + APP_LOGI("[FMS_deleteForm_0300] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0300, 300, "true"); + } else { + APP_LOGE("[FMS_deleteForm_0300] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0300, 300, "false"); + } +} + +void FormAbilityDeleteForm::DeleteForm_0400(int64_t form_id) +{ + bool bResult = DeleteForm(0); + Clear("FMS_deleteForm_0400", form_id); + if(bResult) { + APP_LOGI("[FMS_deleteForm_0400] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0400, 400, "true"); + } else { + APP_LOGE("[FMS_deleteForm_0400] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0400, 400, "false"); + } +} + +void FormAbilityDeleteForm::DeleteForm_0500(int64_t form_id) +{} + +void FormAbilityDeleteForm::DeleteForm_0600(int64_t form_id) +{ + bool bResult = DeleteForm(form_id); + if(bResult) { + APP_LOGI("[FMS_deleteForm_0600] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0600, 600, "true"); + } else { + APP_LOGE("[FMS_deleteForm_0600] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0600, 600, "false"); + } +} + +void FormAbilityDeleteForm::DeleteForm_0700(int64_t form_id, std::string lastFormId) +{ + bool bResult = DeleteForm(form_id); + //Clear + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ONE_NORMAL_FORM, 110, lastFormId); + if(bResult) { + APP_LOGI("[FMS_deleteForm_0700] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0700, 700, "true"); + } else { + APP_LOGE("[FMS_deleteForm_0700] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0700, 700, "false"); + } +} + +void FormAbilityDeleteForm::DeleteForm_0800(int64_t form_id) +{ + bool bResult = DeleteForm(form_id); + if(bResult) { + APP_LOGI("[FMS_deleteForm_0800] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0800, 800, "true"); + } else { + APP_LOGE("[FMS_deleteForm_0800] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0800, 800, "false"); + } +} + +void FormAbilityDeleteForm::DeleteForm_0900(int64_t form_id) +{ + bool bResult = DeleteForm(form_id); + if(bResult) { + bool realResult = DeleteForm(form_id); + if(realResult) { + APP_LOGI("[FMS_deleteForm_0900] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0900, 900, "true"); + } else { + APP_LOGE("[FMS_deleteForm_0900] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0900, 900, "false"); + } + } else { + APP_LOGE("[FMS_deleteForm_0900] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0900, 900, ""); + } +} + +void FormAbilityDeleteForm::DeleteForm_1000(int64_t form_id) +{ + bool bResult = ReleaseForm(form_id); + if(bResult) { + bool realResult = DeleteForm(form_id); + if(realResult) { + APP_LOGI("[FMS_deleteForm_1000] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_1000, 1000, "true"); + } else { + APP_LOGE("[FMS_deleteForm_1000] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_1000, 1000, "false"); + } + } else { + APP_LOGE("[FMS_deleteForm_1000] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_1000, 1000, ""); + } +} +void FormAbilityDeleteForm::DeleteForm_1100(int64_t form_id, std::string lastFormId) +{ + bool bResult = DeleteForm(form_id); + //Clear + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ONE_NORMAL_FORM, 110, lastFormId); + if(bResult) { + APP_LOGI("[FMS_deleteForm_1100] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_1100, 1100, "true"); + } else { + APP_LOGE("[FMS_deleteForm_1100] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_1100, 1100, "false"); + } +} +void FormAbilityDeleteForm::DeleteForm_1200(int64_t form_id) +{} +void FormAbilityDeleteForm::DeleteForm_1400(int64_t form_id) +{} +void FormAbilityDeleteForm::DeleteForm_1500(int64_t form_id) +{} +void FormAbilityDeleteForm::DeleteForm_1600(int64_t form_id) +{} +void FormAbilityDeleteForm::DeleteForm_1700(int64_t form_id) +{} + +void FormAbilityDeleteForm::OnStart(const Want &want) +{ + APP_LOGI("FormAbilityDeleteForm::onStart"); + Ability::OnStart(want); + + std::vector eventList = { + FORM_EVENT_REQ_DELETE_FORM_0300, + FORM_EVENT_REQ_DELETE_FORM_0400, + FORM_EVENT_REQ_DELETE_FORM_0500, + FORM_EVENT_REQ_DELETE_FORM_0600, + FORM_EVENT_REQ_DELETE_FORM_0700, + FORM_EVENT_REQ_DELETE_FORM_0800, + FORM_EVENT_REQ_DELETE_FORM_0900, + FORM_EVENT_REQ_DELETE_FORM_1000, + FORM_EVENT_REQ_DELETE_FORM_1100, + FORM_EVENT_REQ_DELETE_FORM_1200, + FORM_EVENT_REQ_DELETE_FORM_1400, + FORM_EVENT_REQ_DELETE_FORM_1500, + FORM_EVENT_REQ_DELETE_FORM_1600, + FORM_EVENT_REQ_DELETE_FORM_1700 + }; + SubscribeEvent(eventList); +} +void FormAbilityDeleteForm::OnActive() +{ + APP_LOGI("FormAbilityDeleteForm::OnActive"); + Ability::OnActive(); + std::string eventData = GetAbilityName() + FORM_ABILITY_STATE_ONACTIVE; + FormTestUtils::PublishEvent(FORM_EVENT_ABILITY_ONACTIVED, 0, eventData); +} + +void FormAbilityDeleteForm::OnStop() +{ + APP_LOGI("FormAbilityDeleteForm::OnStop"); + + Ability::OnStop(); +} +void FormAbilityDeleteForm::OnInactive() +{ + APP_LOGI("FormAbilityDeleteForm::OnInactive"); + + Ability::OnInactive(); +} +void FormAbilityDeleteForm::OnBackground() +{ + APP_LOGI("FormAbilityDeleteForm::OnBackground"); + + Ability::OnBackground(); +} +void FormAbilityDeleteForm::SubscribeEvent(const std::vector &eventList) +{ + MatchingSkills matchingSkills; + for (const auto &e : eventList) { + matchingSkills.AddEvent(e); + } + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + subscribeInfo.SetPriority(1); + subscriber_ = std::make_shared(subscribeInfo); + subscriber_->ability_ = this; + CommonEventManager::SubscribeCommonEvent(subscriber_); +} + +// KitTest End +void FormAbilityDeleteForm::Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) +{ + APP_LOGI("FormAbilityDeleteForm::Init"); + Ability::Init(abilityInfo, application, handler, token); + memberFuncMap_[FORM_EVENT_REQ_DELETE_FORM_0300] = &FormAbilityDeleteForm::FMS_deleteForm_0300; + memberFuncMap_[FORM_EVENT_REQ_DELETE_FORM_0400] = &FormAbilityDeleteForm::FMS_deleteForm_0400; + memberFuncMap_[FORM_EVENT_REQ_DELETE_FORM_0500] = &FormAbilityDeleteForm::FMS_deleteForm_0500; + memberFuncMap_[FORM_EVENT_REQ_DELETE_FORM_0600] = &FormAbilityDeleteForm::FMS_deleteForm_0600; + memberFuncMap_[FORM_EVENT_REQ_DELETE_FORM_0700] = &FormAbilityDeleteForm::FMS_deleteForm_0700; + memberFuncMap_[FORM_EVENT_REQ_DELETE_FORM_0800] = &FormAbilityDeleteForm::FMS_deleteForm_0800; + memberFuncMap_[FORM_EVENT_REQ_DELETE_FORM_0900] = &FormAbilityDeleteForm::FMS_deleteForm_0900; + memberFuncMap_[FORM_EVENT_REQ_DELETE_FORM_1000] = &FormAbilityDeleteForm::FMS_deleteForm_1000; + memberFuncMap_[FORM_EVENT_REQ_DELETE_FORM_1100] = &FormAbilityDeleteForm::FMS_deleteForm_1100; + memberFuncMap_[FORM_EVENT_REQ_DELETE_FORM_1200] = &FormAbilityDeleteForm::FMS_deleteForm_1200; + memberFuncMap_[FORM_EVENT_REQ_DELETE_FORM_1400] = &FormAbilityDeleteForm::FMS_deleteForm_1400; + memberFuncMap_[FORM_EVENT_REQ_DELETE_FORM_1500] = &FormAbilityDeleteForm::FMS_deleteForm_1500; + memberFuncMap_[FORM_EVENT_REQ_DELETE_FORM_1600] = &FormAbilityDeleteForm::FMS_deleteForm_1600; + memberFuncMap_[FORM_EVENT_REQ_DELETE_FORM_1700] = &FormAbilityDeleteForm::FMS_deleteForm_1700; +} + +void FormAbilityDeleteForm::handleEvent(std::string action, std::string data) +{ + APP_LOGI("%{public}s called", __func__); + auto itFunc = memberFuncMap_.find(action); + if (itFunc != memberFuncMap_.end()) { + auto memberFunc = itFunc->second; + if (memberFunc != nullptr) { + return (this->*memberFunc)(data); + } + } +} + +void FormAbilityDeleteForm::Clear(std::string case_id, int64_t form_id) +{ + bool bResult = DeleteForm(form_id); + if(bResult) { + APP_LOGI("[%{public}s] clear ok", case_id.c_str()); + } else { + APP_LOGE("[%{public}s] clear error", case_id.c_str()); + } +} + +void FormEventSubscriberForDeleteForm::OnReceiveEvent(const CommonEventData &data) +{ + APP_LOGI("FormEventSubscriberForDeleteForm::OnReceiveEvent:event=%{public}s", data.GetWant().GetAction().c_str()); + APP_LOGI("FormEventSubscriberForDeleteForm::OnReceiveEvent:code=%{public}d", data.GetCode()); + auto eventName = data.GetWant().GetAction(); + ability_->handleEvent(eventName, data.GetData()); + CommonEventManager::UnSubscribeCommonEvent(ability_->subscriber_); +} + +void FormEventSubscriberForDeleteForm::KitTerminateAbility() +{ + if (ability_ != nullptr) { + ability_->TerminateAbility(); + } +} + +REGISTER_AA(FormAbilityDeleteForm) +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNormal/src/form_ability_releaseform.cpp b/test/resource/formsystemtestability/fmsSystemTestHostNormal/src/form_ability_releaseform.cpp new file mode 100644 index 0000000000..480b550380 --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNormal/src/form_ability_releaseform.cpp @@ -0,0 +1,641 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "app_log_wrapper.h" +#include +#include +#include +#include "form_ability_releaseform.h" +#include "form_test_utils.h" +#include "form_st_common_info.h" + +namespace { +using namespace OHOS::AAFwk; +using namespace OHOS::EventFwk; +} + +namespace OHOS { +namespace AppExecFwk { +void FormAbilityReleaseForm::AcquireFormCallback::OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called", __func__); + APP_LOGI("%{public}s receive formId:%{public}s", __func__, std::to_string(formJsInfo.formId).c_str()); + //FormTestUtils::PublishEvent(this->caseName_, 0, std::to_string(formJsInfo.formId)); + if (this->caseName_ == FORM_EVENT_RECV_RELEASE_FORM_0700 || this->caseName_ == FORM_EVENT_RECV_RELEASE_FORM_1000) { + //ability_->FMS_releaseForm_common(formJsInfo.formId, this->caseName_, this->lastformId_); + ability_->FMS_releaseForm_common(atoll(this->lastformId_.c_str()), this->caseName_, this->lastformId_); + } +} +void FormAbilityReleaseForm::AcquireFormCallback::OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called", __func__); + APP_LOGI("%{public}s receive formData:%{public}s", __func__, formJsInfo.formData.c_str()); + //FormTestUtils::PublishEvent(this->caseName_, 1, formJsInfo.formData); + if (this->caseName_ == FORM_EVENT_RECV_RELEASE_FORM_0300 || this->caseName_ == FORM_EVENT_RECV_RELEASE_FORM_0400 + || this->caseName_ == FORM_EVENT_RECV_RELEASE_FORM_0600 || this->caseName_ == FORM_EVENT_RECV_RELEASE_FORM_0800 + || this->caseName_ == FORM_EVENT_RECV_RELEASE_FORM_0900 || this->caseName_ == FORM_EVENT_RECV_RELEASE_FORM_1100 + || this->caseName_ == FORM_EVENT_RECV_RELEASE_FORM_1200 || this->caseName_ == FORM_EVENT_RECV_RELEASE_FORM_1300 + || this->caseName_ == FORM_EVENT_RECV_RELEASE_FORM_1400) { + ability_->FMS_releaseForm_common(formJsInfo.formId, this->caseName_, this->lastformId_); + } +} + +void FormAbilityReleaseForm::AcquireFormCallback::OnFormUninstall(const int64_t formId) const +{ + APP_LOGI("%{public}s called", __func__); +} + +void FormAbilityReleaseForm::FMS_releaseForm_common(int64_t formId, std::string caseName, std::string lastFormId) +{ + APP_LOGI("%{public}s called, formId: %{public}s, caseName:%{public}s, lastFormId:%{public}s", + __func__, std::to_string(formId), caseName.c_str(), lastFormId.c_str()); + if(caseName == FORM_EVENT_RECV_RELEASE_FORM_0300) { + ReleaseForm_0300(formId); + } else if (caseName == FORM_EVENT_RECV_RELEASE_FORM_0400) { + ReleaseForm_0400(formId); + } else if (caseName == FORM_EVENT_RECV_RELEASE_FORM_0600) { + ReleaseForm_0600(formId); + } else if (caseName == FORM_EVENT_RECV_RELEASE_FORM_0700) { + ReleaseForm_0700(formId, lastFormId); + } else if (caseName == FORM_EVENT_RECV_RELEASE_FORM_0800) { + ReleaseForm_0800(formId, lastFormId); + } else if (caseName == FORM_EVENT_RECV_RELEASE_FORM_0900) { + ReleaseForm_0900(formId); + } else if (caseName == FORM_EVENT_RECV_RELEASE_FORM_1000) { + ReleaseForm_1000(formId, lastFormId); + } else if (caseName == FORM_EVENT_RECV_RELEASE_FORM_1100) { + ReleaseForm_1100(formId, lastFormId); + } else if (caseName == FORM_EVENT_RECV_RELEASE_FORM_1200) { + ReleaseForm_1200(formId); + } else if (caseName == FORM_EVENT_RECV_RELEASE_FORM_1300) { + ReleaseForm_1300(formId, lastFormId); + } else if (caseName == FORM_EVENT_RECV_RELEASE_FORM_1400) { + ReleaseForm_1400(formId); + } else { + return; + } +} + +void FormAbilityReleaseForm::FMS_releaseForm_0300(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_RELEASE_FORM_0300, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_releaseForm_0300] AcquireForm ok."); + } else { + APP_LOGE("[FMS_releaseForm_0300] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0300, 300, ""); + } +} +void FormAbilityReleaseForm::FMS_releaseForm_0400(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_RELEASE_FORM_0400, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_releaseForm_0400] AcquireForm ok."); + } else { + APP_LOGE("[FMS_releaseForm_0400] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0400, 400, ""); + } +} + +void FormAbilityReleaseForm::FMS_releaseForm_0500(std::string data) +{ + APP_LOGI("[FMS_releaseForm_0500] start[%{public}s]", data.c_str()); + bool bResult = ReleaseForm(atoll(data.c_str()), true); + //Clear + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ONE_NORMAL_FORM, 110, data); + if(bResult) { + APP_LOGI("[FMS_releaseForm_0500] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0500, 500, "true"); + } else { + APP_LOGE("[FMS_releaseForm_0500] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0500, 500, "false"); + } +} + +void FormAbilityReleaseForm::FMS_releaseForm_0600(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_RELEASE_FORM_0600, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_releaseForm_0600] AcquireForm ok."); + } else { + APP_LOGE("[FMS_releaseForm_0600] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0600, 600, ""); + } +} + +void FormAbilityReleaseForm::FMS_releaseForm_0700(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_RELEASE_FORM_0700, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(atoll(data.c_str()), want, callback); + if(bResult) { + APP_LOGI("[FMS_releaseForm_0700] AcquireForm ok."); + } else { + APP_LOGE("[FMS_releaseForm_0700] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0700, 700, ""); + } +} + +void FormAbilityReleaseForm::FMS_releaseForm_0800(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_RELEASE_FORM_0800, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_releaseForm_0800] AcquireForm ok."); + } else { + APP_LOGE("[FMS_releaseForm_0800] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0800, 800, ""); + } +} +void FormAbilityReleaseForm::FMS_releaseForm_0900(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_RELEASE_FORM_0900, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_releaseForm_0900] AcquireForm ok."); + } else { + APP_LOGE("[FMS_releaseForm_0900] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0900, 900, ""); + } +} + +void FormAbilityReleaseForm::FMS_releaseForm_1000(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_RELEASE_FORM_1000, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(atoll(data.c_str()), want, callback); + if(bResult) { + APP_LOGI("[FMS_releaseForm_1000] AcquireForm ok."); + } else { + APP_LOGE("[FMS_releaseForm_1000] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_1000, 1000, ""); + } +} + +void FormAbilityReleaseForm::FMS_releaseForm_1100(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_RELEASE_FORM_1100, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_releaseForm_1100] AcquireForm ok."); + } else { + APP_LOGE("[FMS_releaseForm_1100] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_1100, 1100, ""); + } +} + +void FormAbilityReleaseForm::FMS_releaseForm_1200(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_RELEASE_FORM_1200, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_releaseForm_1200] AcquireForm ok."); + } else { + APP_LOGE("[FMS_releaseForm_1200] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_1200, 1200, ""); + } +} + +void FormAbilityReleaseForm::FMS_releaseForm_1300(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_RELEASE_FORM_1300, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_releaseForm_1300] AcquireForm ok."); + } else { + APP_LOGE("[FMS_releaseForm_1300] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_1300, 1300, ""); + } +} + +void FormAbilityReleaseForm::FMS_releaseForm_1400(std::string data) +{ + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_RELEASE_FORM_1400, data); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_TRUE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("[FMS_releaseForm_1400] AcquireForm ok."); + } else { + APP_LOGE("[FMS_releaseForm_1400] AcquireForm error."); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_1400, 1400, ""); + } +} + +void FormAbilityReleaseForm::ReleaseForm_0300(int64_t form_id) +{ + int64_t formId = -1; + bool isReleaseCache = true; + bool bResult = ReleaseForm(formId, isReleaseCache); + Clear("FMS_releaseForm_0300", form_id); + if(bResult) { + APP_LOGI("[FMS_releaseForm_0300] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0300, 300, "true"); + } else { + APP_LOGE("[FMS_releaseForm_0300] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0300, 300, "false"); + } +} + +void FormAbilityReleaseForm::ReleaseForm_0400(int64_t form_id) +{ + int64_t formId = 0; + bool isReleaseCache = true; + bool bResult = ReleaseForm(formId, isReleaseCache); + Clear("FMS_releaseForm_0400", form_id); + if(bResult) { + APP_LOGI("[FMS_releaseForm_0400] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0400, 400, "true"); + } else { + APP_LOGE("[FMS_releaseForm_0400] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0400, 400, "false"); + } +} + +void FormAbilityReleaseForm::ReleaseForm_0500(int64_t form_id) +{} + +void FormAbilityReleaseForm::ReleaseForm_0600(int64_t form_id) +{ + bool bResult = DeleteForm(form_id); + if(bResult) { + bool isReleaseCache = true; + bool realResult = ReleaseForm(form_id, isReleaseCache); + if(realResult) { + APP_LOGI("[FMS_releaseForm_0600] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0600, 600, "true"); + } else { + APP_LOGE("[FMS_releaseForm_0600] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0600, 600, "false"); + } + } else { + APP_LOGE("[FMS_releaseForm_0600] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0600, 600, ""); + } +} + +void FormAbilityReleaseForm::ReleaseForm_0700(int64_t form_id, std::string lastFormId) +{ + bool isReleaseCache = false; + bool bResult = ReleaseForm(form_id, isReleaseCache); + //Clear + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ONE_NORMAL_FORM, 110, lastFormId); + Clear("FMS_releaseForm_0700", form_id); + if(bResult) { + APP_LOGI("[FMS_releaseForm_0700] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0700, 700, "true"); + } else { + APP_LOGE("[FMS_releaseForm_0700] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0700, 700, "false"); + } +} +void FormAbilityReleaseForm::ReleaseForm_0800(int64_t form_id, std::string lastFormId) +{ + bool isReleaseCache = false; + bool bResult = ReleaseForm(form_id, isReleaseCache); + //Clear + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ONE_NORMAL_FORM, 110, lastFormId); + Clear("FMS_releaseForm_0800", form_id); + if(bResult) { + APP_LOGI("[FMS_releaseForm_0800] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0800, 800, "true"); + } else { + APP_LOGE("[FMS_releaseForm_0800] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0800, 800, "false"); + } +} +void FormAbilityReleaseForm::ReleaseForm_0900(int64_t form_id) +{ + bool isReleaseCache = false; + bool bResult = ReleaseForm(form_id, isReleaseCache); + Clear("FMS_releaseForm_0900", form_id); + if(bResult) { + APP_LOGI("[FMS_releaseForm_0900] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0900, 900, "true"); + } else { + APP_LOGE("[FMS_releaseForm_0900] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0900, 900, "false"); + } +} +void FormAbilityReleaseForm::ReleaseForm_1000(int64_t form_id, std::string lastFormId) +{ + bool isReleaseCache = true; + bool bResult = ReleaseForm(form_id, isReleaseCache); + //Clear + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ONE_NORMAL_FORM, 110, lastFormId); + Clear("FMS_releaseForm_1000", form_id); + if(bResult) { + APP_LOGI("[FMS_releaseForm_1000] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_1000, 1000, "true"); + } else { + APP_LOGE("[FMS_releaseForm_1000] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_1000, 1000, "false"); + } +} +void FormAbilityReleaseForm::ReleaseForm_1100(int64_t form_id, std::string lastFormId) +{ + bool isReleaseCache = true; + bool bResult = ReleaseForm(form_id, isReleaseCache); + //Clear + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ONE_NORMAL_FORM, 110, lastFormId); + Clear("FMS_releaseForm_1100", form_id); + if(bResult) { + APP_LOGI("[FMS_releaseForm_1100] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_1100, 1100, "true"); + } else { + APP_LOGE("[FMS_releaseForm_1100] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_1100, 1100, "false"); + } +} +void FormAbilityReleaseForm::ReleaseForm_1200(int64_t form_id) +{ + bool isReleaseCache = true; + bool bResult = ReleaseForm(form_id, isReleaseCache); + Clear("FMS_releaseForm_1200", form_id); + if(bResult) { + APP_LOGI("[FMS_releaseForm_1200] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_1200, 1200, "true"); + } else { + APP_LOGE("[FMS_releaseForm_1200] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_1200, 1200, "false"); + } +} +void FormAbilityReleaseForm::ReleaseForm_1300(int64_t form_id, std::string lastFormId) +{ + if (lastFormId == "") { + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_1300, 1300, std::to_string(form_id)); + } else { + bool isReleaseCache = true; + bool bResult1 = ReleaseForm(form_id, isReleaseCache); + bool bResult2 = ReleaseForm(atoll(lastFormId.c_str()), isReleaseCache); + Clear("FMS_releaseForm_1300", form_id); + Clear("FMS_releaseForm_1300", atoll(lastFormId.c_str())); + if (bResult1 && bResult2) { + APP_LOGI("[FMS_releaseForm_1300] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_1300, 1300, "true"); + } else { + APP_LOGE("[FMS_releaseForm_1300] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_1300, 1300, "false"); + } + } +} +void FormAbilityReleaseForm::ReleaseForm_1400(int64_t form_id) +{ + bool isReleaseCache = true; + bool bResult = ReleaseForm(form_id, isReleaseCache); + Clear("FMS_releaseForm_1400", form_id); + if(bResult) { + APP_LOGI("[FMS_releaseForm_1400] end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_1400, 1400, "true"); + } else { + APP_LOGE("[FMS_releaseForm_1400] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_1400, 1400, "false"); + } +} + +void FormAbilityReleaseForm::OnStart(const Want &want) +{ + APP_LOGI("FormAbilityReleaseForm::onStart"); + Ability::OnStart(want); + + std::vector eventList = { + FORM_EVENT_REQ_RELEASE_FORM_0300, + FORM_EVENT_REQ_RELEASE_FORM_0400, + FORM_EVENT_REQ_RELEASE_FORM_0500, + FORM_EVENT_REQ_RELEASE_FORM_0600, + FORM_EVENT_REQ_RELEASE_FORM_0700, + FORM_EVENT_REQ_RELEASE_FORM_0800, + FORM_EVENT_REQ_RELEASE_FORM_0900, + FORM_EVENT_REQ_RELEASE_FORM_1000, + FORM_EVENT_REQ_RELEASE_FORM_1100, + FORM_EVENT_REQ_RELEASE_FORM_1200, + FORM_EVENT_REQ_RELEASE_FORM_1300, + FORM_EVENT_REQ_RELEASE_FORM_1400, + }; + SubscribeEvent(eventList); +} +void FormAbilityReleaseForm::OnActive() +{ + APP_LOGI("FormAbilityReleaseForm::OnActive"); + Ability::OnActive(); + std::string eventData = GetAbilityName() + FORM_ABILITY_STATE_ONACTIVE; + FormTestUtils::PublishEvent(FORM_EVENT_ABILITY_ONACTIVED, 0, eventData); +} + +void FormAbilityReleaseForm::OnStop() +{ + APP_LOGI("FormAbilityReleaseForm::OnStop"); + + Ability::OnStop(); +} +void FormAbilityReleaseForm::OnInactive() +{ + APP_LOGI("FormAbilityReleaseForm::OnInactive"); + + Ability::OnInactive(); +} +void FormAbilityReleaseForm::OnBackground() +{ + APP_LOGI("FormAbilityReleaseForm::OnBackground"); + + Ability::OnBackground(); +} +void FormAbilityReleaseForm::SubscribeEvent(const std::vector &eventList) +{ + MatchingSkills matchingSkills; + for (const auto &e : eventList) { + matchingSkills.AddEvent(e); + } + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + subscribeInfo.SetPriority(1); + subscriber_ = std::make_shared(subscribeInfo); + subscriber_->ability_ = this; + CommonEventManager::SubscribeCommonEvent(subscriber_); +} + +// KitTest End +void FormAbilityReleaseForm::Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) +{ + APP_LOGI("FormAbilityReleaseForm::Init"); + Ability::Init(abilityInfo, application, handler, token); + memberFuncMap_[FORM_EVENT_REQ_RELEASE_FORM_0300] = &FormAbilityReleaseForm::FMS_releaseForm_0300; + memberFuncMap_[FORM_EVENT_REQ_RELEASE_FORM_0400] = &FormAbilityReleaseForm::FMS_releaseForm_0400; + memberFuncMap_[FORM_EVENT_REQ_RELEASE_FORM_0500] = &FormAbilityReleaseForm::FMS_releaseForm_0500; + memberFuncMap_[FORM_EVENT_REQ_RELEASE_FORM_0600] = &FormAbilityReleaseForm::FMS_releaseForm_0600; + memberFuncMap_[FORM_EVENT_REQ_RELEASE_FORM_0700] = &FormAbilityReleaseForm::FMS_releaseForm_0700; + memberFuncMap_[FORM_EVENT_REQ_RELEASE_FORM_0800] = &FormAbilityReleaseForm::FMS_releaseForm_0800; + memberFuncMap_[FORM_EVENT_REQ_RELEASE_FORM_0900] = &FormAbilityReleaseForm::FMS_releaseForm_0900; + memberFuncMap_[FORM_EVENT_REQ_RELEASE_FORM_1000] = &FormAbilityReleaseForm::FMS_releaseForm_1000; + memberFuncMap_[FORM_EVENT_REQ_RELEASE_FORM_1100] = &FormAbilityReleaseForm::FMS_releaseForm_1100; + memberFuncMap_[FORM_EVENT_REQ_RELEASE_FORM_1200] = &FormAbilityReleaseForm::FMS_releaseForm_1200; + memberFuncMap_[FORM_EVENT_REQ_RELEASE_FORM_1300] = &FormAbilityReleaseForm::FMS_releaseForm_1300; + memberFuncMap_[FORM_EVENT_REQ_RELEASE_FORM_1400] = &FormAbilityReleaseForm::FMS_releaseForm_1400; +} + +void FormAbilityReleaseForm::handleEvent(std::string action, std::string data) +{ + APP_LOGI("%{public}s called", __func__); + auto itFunc = memberFuncMap_.find(action); + if (itFunc != memberFuncMap_.end()) { + auto memberFunc = itFunc->second; + if (memberFunc != nullptr) { + return (this->*memberFunc)(data); + } + } +} + +void FormAbilityReleaseForm::Clear(std::string case_id, int64_t form_id) +{ + bool bResult = DeleteForm(form_id); + if(bResult) { + APP_LOGI("[%{public}s] clear ok", case_id.c_str()); + } else { + APP_LOGE("[%{public}s] clear error", case_id.c_str()); + } +} + +void FormEventSubscriberForReleaseForm::OnReceiveEvent(const CommonEventData &data) +{ + APP_LOGI("FormEventSubscriberForReleaseForm::OnReceiveEvent:event=%{public}s", data.GetWant().GetAction().c_str()); + APP_LOGI("FormEventSubscriberForReleaseForm::OnReceiveEvent:code=%{public}d", data.GetCode()); + auto eventName = data.GetWant().GetAction(); + ability_->handleEvent(eventName, data.GetData()); + if(data.GetCode() == 1300 && data.GetData() == "") { + return; + } else { + CommonEventManager::UnSubscribeCommonEvent(ability_->subscriber_); + } +} + +void FormEventSubscriberForReleaseForm::KitTerminateAbility() +{ + if (ability_ != nullptr) { + ability_->TerminateAbility(); + } +} + +REGISTER_AA(FormAbilityReleaseForm) +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNormalB/BUILD.gn b/test/resource/formsystemtestability/fmsSystemTestHostNormalB/BUILD.gn new file mode 100755 index 0000000000..3f20684548 --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNormalB/BUILD.gn @@ -0,0 +1,70 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import("//build/ohos.gni") +import("//foundation/appexecfwk/standard/appexecfwk.gni") + +config("fmsSystemTestHostNormalBConfig") { + visibility = [ ":*" ] + include_dirs = [ + "include", + "../tool/include", + "${appexecfwk_path}/test/systemtest/common/fms/common/include", + "${aafwk_path}/interfaces/innerkits/ability_manager/include", + "${aafwk_path}/interfaces/innerkits/want/include/ohos/aafwk/content", + "${aafwk_path}/services/abilitymgr/include", + "${appexecfwk_path}/common/log/include", + "${appexecfwk_path}/interfaces/innerkits/libeventhandler/include", + "${appexecfwk_path}/kits/appkit/native/app", + "${appexecfwk_path}/services/bundlemgr/include", + "//foundation/distributedschedule/dmsfwk/services/dtbschedmgr/include", + "//utils/system/safwk/native/include", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core/include/appmgr", + "//third_party/jsoncpp/include", + ] + defines = [ + "APP_LOG_TAG = \"formManagerSystemTest\"", + "LOG_DOMAIN = 0xD002666", + ] +} +ohos_shared_library("fmsSystemTestHostNormalB") { + sources = [ + "../tool/src/form_test_utils.cpp", + "src/form_ability_b.cpp", + ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + configs = [ ":fmsSystemTestHostNormalBConfig" ] + deps = [ + "${aafwk_path}/frameworks/kits/ability/native:abilitykit_native", + "${aafwk_path}/interfaces/innerkits/base:base", + "${aafwk_path}/interfaces/innerkits/want:want", + "${appexecfwk_path}/common:libappexecfwk_common", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core:appexecfwk_core", + "${appexecfwk_path}/kits:appkit_native", + "${appexecfwk_path}/services/bundlemgr:libbms", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//third_party/jsoncpp:jsoncpp", + "//utils/native/base:utilsbase", + ] + external_deps = [ + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] + subsystem_name = "formsystemtestability" +} diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNormalB/config.json b/test/resource/formsystemtestability/fmsSystemTestHostNormalB/config.json new file mode 100644 index 0000000000..5102f274b6 --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNormalB/config.json @@ -0,0 +1,80 @@ +{ + "app":{ + "bundleName": "com.ohos.form.manager.normalb", + "vendor": "ix", + "version": { + "code": 1, + "name": "1.0" + }, + "apiVersion": { + "compatible": 3, + "target": 3 + } + }, + "deviceConfig": { + "default": { + } + }, + "module": { + "package":"com.ohos.form.manager.normalb.FormAbility", + "name":"FormAbility", + "deviceType": [ + "phone" + ], + "distro": { + "deliveryWithInstall": true, + "moduleName": "FormAbilityB", + "moduleType": "entry" + }, + "abilities": [{ + "name": "FormAbilityB", + "icon": "$media:snowball", + "srcLanguage": "c++", + "label": "Form Ability B", + "launchType": "standard", + "orientation": "unspecified", + "type": "page", + "visible": true, + "skills": [ + { + "actions": [ + "ohos.aafwk.content.Want.ACTION_HOME" + ], + "entities": [ + "ohos.aafwk.content.Want.ENTITY_HOME" + ], + "attributes": [] + } + ] + }], + "defPermissions": [ + { + "name": "ohos.permission.REQUIRE_FORM", + "grantMode": "system_grant", + "label": "$string:entry_MainAbility", + "description": "REQUIRE_FORM permission in detail" + } + ], + "reqPermissions": [ + { + "name": "ohos.permission.REQUIRE_FORM", + "reason": "fmsStressTest100", + "usedScene": { + "ability": [ + ".MainAbility" + ], + "when": "always" + } + } + ], + "js": [ + { + "name": "formDemo", + "pages": [ + "pages/index/index" + ], + "type": "form" + } + ] + } +} \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNormalB/include/form_ability_b.h b/test/resource/formsystemtestability/fmsSystemTestHostNormalB/include/form_ability_b.h new file mode 100644 index 0000000000..88a7b9ad1c --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNormalB/include/form_ability_b.h @@ -0,0 +1,104 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _FORM_ABILITY_A_H_ +#define _FORM_ABILITY_A_H_ +#include "ability_loader.h" +#include "common_event.h" +#include "common_event_manager.h" + +namespace OHOS { +namespace AppExecFwk { +class FormEventSubscriber; +class FormAbilityB : public Ability { +public: + ~FormAbilityB(); + void SubscribeEvent(); + void handleEvent(std::string action, std::string data); + + void FMS_deleteFormCommon(int64_t formId); + + void FMS_acquireForm_1400(std::string data); + void FMS_acquireForm_1500(std::string data); + void FMS_acquireForm_1800_2(std::string data); + void FMS_acquireForm_1800_3(std::string data); + void FMS_acquireForm_1900(std::string data); + void FMS_acquireForm_2100(std::string data); + void FMS_acquireForm_2200(std::string data); + void FMS_acquireForm_2300(std::string data); + void FMS_acquireForm_2400(std::string data); + void FMS_acquireForm_2600(std::string data); + void FMS_acquireForm_2700(std::string data); + void FMS_acquireForm_2800(std::string data); + void FMS_acquireForm_2900(std::string data); + void FMS_acquireForm_3000(std::string data); + void FMS_acquireForm_3100(std::string data); + void FMS_acquireForm_3200(std::string data); + void FMS_acquireForm_3300(std::string data); + void FMS_acquireForm_3400(std::string data); + void FMS_acquireForm_3500(std::string data); + + std::shared_ptr subscriber_; + + class AcquireFormCallback : public FormCallback { + public: + AcquireFormCallback(std::string name, int code):caseName_(name), code_(code) + { + } + virtual ~AcquireFormCallback() = default; + void OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnFormUninstall(const int64_t formId) const override; + + std::string caseName_ = ""; + int code_ = 0; + FormAbilityB *ability_; + }; +protected: + virtual void Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) override; + virtual void OnStart(const Want &want) override; + virtual void OnStop() override; + virtual void OnActive() override; + virtual void OnInactive() override; + virtual void OnBackground() override; +private: + void Clear(); + + using FormFunc = void (FormAbilityB::*)(std::string data); + std::map memberFuncMap_; + std::map calledFuncMap_; + std::shared_ptr callback_; +}; + +class FormEventSubscriber : public EventFwk::CommonEventSubscriber { +public: + FormEventSubscriber(const EventFwk::CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp) + { + ability_ = nullptr; + } + ~FormEventSubscriber() + { + ability_ = nullptr; + } + virtual void OnReceiveEvent(const EventFwk::CommonEventData &data) override; + void KitTerminateAbility(); + + FormAbilityB *ability_; +}; +} // namespace AppExecFwk +} // namespace OHOS +#endif // _FORM_ABILITY_A_H_ \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNormalB/src/form_ability_b.cpp b/test/resource/formsystemtestability/fmsSystemTestHostNormalB/src/form_ability_b.cpp new file mode 100644 index 0000000000..d5edd50bb7 --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNormalB/src/form_ability_b.cpp @@ -0,0 +1,311 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "app_log_wrapper.h" +#include "form_ability_b.h" +#include +#include +#include +#include "form_test_utils.h" +#include "form_st_common_info.h" + +namespace { +using namespace OHOS::AAFwk; +using namespace OHOS::EventFwk; +} + +namespace OHOS { +namespace AppExecFwk { +std::vector eventList = { + FORM_EVENT_REQ_ACQUIRE_FORM_1400, FORM_EVENT_REQ_ACQUIRE_FORM_1500, + FORM_EVENT_REQ_ACQUIRE_FORM_1800_2, FORM_EVENT_REQ_ACQUIRE_FORM_1800_3, +}; +void FormAbilityB::AcquireFormCallback::OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called", __func__); + FormTestUtils::PublishEvent(this->caseName_, this->code_, std::to_string(formJsInfo.formId)); + if(this->caseName_ == FORM_EVENT_RECV_ACQUIRE_FORM_1500) { + APP_LOGI("%{public}s, delete form", __func__); + ability_->FMS_deleteFormCommon(formJsInfo.formId); + } +} +void FormAbilityB::AcquireFormCallback::OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called", __func__); + FormTestUtils::PublishEvent(this->caseName_, this->code_ + 1, formJsInfo.formData); + if(this->caseName_ == FORM_EVENT_RECV_ACQUIRE_FORM_1800_2 || this->caseName_ == FORM_EVENT_RECV_ACQUIRE_FORM_1800_3) { + APP_LOGI("%{public}s, delete form", __func__); + ability_->FMS_deleteFormCommon(formJsInfo.formId); + } +} + +void FormAbilityB::AcquireFormCallback::OnFormUninstall(const int64_t formId) const +{ + APP_LOGI("%{public}s called", __func__); +} +void FormAbilityB::FMS_deleteFormCommon(int64_t formId) +{ + APP_LOGI("%{public}s called, formId: %{public}lld", __func__, formId); + bool bResult = DeleteForm(formId); + sleep(1); + if(bResult) { + APP_LOGI("DeleteForm end"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_COMMON, 999, "true"); + } else { + APP_LOGE("DeleteForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_COMMON, 999, "false"); + } +} + +void FormAbilityB::FMS_acquireForm_1400(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_1400, 1400); + // Set Want info begin + std::string formName = "formName999"; + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, formName); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + int64_t formId = std::stoll(data); + bool bResult = AcquireForm(formId, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_1400, 1400, "false"); + } +} +void FormAbilityB::FMS_acquireForm_1500(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_1500, 1500); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + int64_t formId = std::stoll(data); + bool bResult = AcquireForm(formId, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_1500, 1500, ""); + } +} + +void FormAbilityB::FMS_acquireForm_1800_2(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_1800_2, 1820); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_1800_2, 1820, ""); + } +} +void FormAbilityB::FMS_acquireForm_1800_3(std::string data) +{ + APP_LOGI("%{public}s called", __func__); + std::shared_ptr callback = + std::make_shared(FORM_EVENT_RECV_ACQUIRE_FORM_1800_3, 1830); + callback->ability_ = this; + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_TRUE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_1800_3, 1830, ""); + } +} +void FormAbilityB::FMS_acquireForm_1900(std::string data) +{ +} +void FormAbilityB::FMS_acquireForm_2100(std::string data) +{ +} +void FormAbilityB::FMS_acquireForm_2200(std::string data) +{ +} +void FormAbilityB::FMS_acquireForm_2300(std::string data) +{ +} +void FormAbilityB::FMS_acquireForm_2400(std::string data) +{ +} +void FormAbilityB::FMS_acquireForm_2600(std::string data) +{ +} +void FormAbilityB::FMS_acquireForm_2700(std::string data) +{ +} +void FormAbilityB::FMS_acquireForm_2800(std::string data) +{ +} +void FormAbilityB::FMS_acquireForm_2900(std::string data) +{ +} +void FormAbilityB::FMS_acquireForm_3000(std::string data) +{ +} +void FormAbilityB::FMS_acquireForm_3100(std::string data) +{ +} +void FormAbilityB::FMS_acquireForm_3200(std::string data) +{ +} +void FormAbilityB::FMS_acquireForm_3300(std::string data) +{ +} +void FormAbilityB::FMS_acquireForm_3400(std::string data) +{ +} +void FormAbilityB::FMS_acquireForm_3500(std::string data) +{ +} + +FormAbilityB::~FormAbilityB() +{ + CommonEventManager::UnSubscribeCommonEvent(subscriber_); +} +void FormAbilityB::OnStart(const Want &want) +{ + APP_LOGI("FormAbilityB::onStart"); + Ability::OnStart(want); +} +void FormAbilityB::OnActive() +{ + APP_LOGI("FormAbilityB::OnActive"); + Ability::OnActive(); + std::string eventData = GetAbilityName() + FORM_ABILITY_STATE_ONACTIVE; + FormTestUtils::PublishEvent(FORM_EVENT_ABILITY_ONACTIVED, 0, eventData); +} + +void FormAbilityB::OnStop() +{ + APP_LOGI("FormAbilityB::OnStop"); + + Ability::OnStop(); +} +void FormAbilityB::OnInactive() +{ + APP_LOGI("FormAbilityB::OnInactive"); + + Ability::OnInactive(); +} +void FormAbilityB::OnBackground() +{ + APP_LOGI("FormAbilityB::OnBackground"); + + Ability::OnBackground(); +} +void FormAbilityB::SubscribeEvent() +{ + APP_LOGI("FormAbilityB::SubscribeEvent"); + MatchingSkills matchingSkills; + for (const auto &e : eventList) { + matchingSkills.AddEvent(e); + } + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + subscribeInfo.SetPriority(1); + subscriber_ = std::make_shared(subscribeInfo); + subscriber_->ability_ = this; + CommonEventManager::SubscribeCommonEvent(subscriber_); +} + +// KitTest End +void FormAbilityB::Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) +{ + APP_LOGI("FormAbilityB::Init"); + Ability::Init(abilityInfo, application, handler, token); + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_1400] = &FormAbilityB::FMS_acquireForm_1400; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_1500] = &FormAbilityB::FMS_acquireForm_1500; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_1800_2] = &FormAbilityB::FMS_acquireForm_1800_2; + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_1800_3] = &FormAbilityB::FMS_acquireForm_1800_3; + + SubscribeEvent(); +} + +void FormAbilityB::handleEvent(std::string action, std::string data) +{ + APP_LOGI("%{public}s called", __func__); + if(calledFuncMap_.find(action) != calledFuncMap_.end()) { + return; + } + calledFuncMap_.emplace(action, 0); + auto itFunc = memberFuncMap_.find(action); + if (itFunc != memberFuncMap_.end()) { + auto memberFunc = itFunc->second; + if (memberFunc != nullptr) { + return (this->*memberFunc)(data); + } + } +} + +void FormAbilityB::Clear() +{ +} + +void FormEventSubscriber::OnReceiveEvent(const CommonEventData &data) +{ + APP_LOGI("FormEventSubscriber::OnReceiveEvent:event=%{public}s", data.GetWant().GetAction().c_str()); + APP_LOGI("KitTestEventSubscriber::OnReceiveEvent:data=%{public}s", data.GetData().c_str()); + APP_LOGI("FormEventSubscriber::OnReceiveEvent:code=%{public}d", data.GetCode()); + auto eventName = data.GetWant().GetAction(); + ability_->handleEvent(eventName, data.GetData()); + CommonEventManager::UnSubscribeCommonEvent(ability_->subscriber_); +} + +void FormEventSubscriber::KitTerminateAbility() +{ + if (ability_ != nullptr) { + ability_->TerminateAbility(); + } +} + +REGISTER_AA(FormAbilityB) +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNotSys/BUILD.gn b/test/resource/formsystemtestability/fmsSystemTestHostNotSys/BUILD.gn new file mode 100755 index 0000000000..6c67d9f296 --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNotSys/BUILD.gn @@ -0,0 +1,70 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import("//build/ohos.gni") +import("//foundation/appexecfwk/standard/appexecfwk.gni") + +config("fmsSystemTestHostNotSysConfig") { + visibility = [ ":*" ] + include_dirs = [ + "include", + "../tool/include", + "${appexecfwk_path}/test/systemtest/common/fms/common/include", + "${aafwk_path}/interfaces/innerkits/ability_manager/include", + "${aafwk_path}/interfaces/innerkits/want/include/ohos/aafwk/content", + "${aafwk_path}/services/abilitymgr/include", + "${appexecfwk_path}/common/log/include", + "${appexecfwk_path}/interfaces/innerkits/libeventhandler/include", + "${appexecfwk_path}/kits/appkit/native/app", + "${appexecfwk_path}/services/bundlemgr/include", + "//foundation/distributedschedule/dmsfwk/services/dtbschedmgr/include", + "//utils/system/safwk/native/include", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core/include/appmgr", + "//third_party/jsoncpp/include", + ] + defines = [ + "APP_LOG_TAG = \"formManagerSystemTest\"", + "LOG_DOMAIN = 0xD002666", + ] +} +ohos_shared_library("fmsSystemTestHostNotSys") { + sources = [ + "../tool/src/form_test_utils.cpp", + "src/form_ability_not_sys.cpp", + ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + configs = [ ":fmsSystemTestHostNotSysConfig" ] + deps = [ + "${aafwk_path}/frameworks/kits/ability/native:abilitykit_native", + "${aafwk_path}/interfaces/innerkits/base:base", + "${aafwk_path}/interfaces/innerkits/want:want", + "${appexecfwk_path}/common:libappexecfwk_common", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core:appexecfwk_core", + "${appexecfwk_path}/kits:appkit_native", + "${appexecfwk_path}/services/bundlemgr:libbms", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//third_party/jsoncpp:jsoncpp", + "//utils/native/base:utilsbase", + ] + external_deps = [ + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] + subsystem_name = "formsystemtestability" +} diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNotSys/config.json b/test/resource/formsystemtestability/fmsSystemTestHostNotSys/config.json new file mode 100644 index 0000000000..bf7d51772e --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNotSys/config.json @@ -0,0 +1,80 @@ +{ + "app":{ + "bundleName": "com.ohos.form.manager.notsystemapp", + "vendor": "ix", + "version": { + "code": 1, + "name": "1.0" + }, + "apiVersion": { + "compatible": 3, + "target": 3 + } + }, + "deviceConfig": { + "default": { + } + }, + "module": { + "package":"com.ohos.form.manager.notsystemapp.FormAbility", + "name":"FormAbility", + "deviceType": [ + "phone" + ], + "distro": { + "deliveryWithInstall": true, + "moduleName": "FormAbility", + "moduleType": "entry" + }, + "abilities": [{ + "name": "FormAbilityNotSys", + "icon": "$media:snowball", + "srcLanguage": "c++", + "label": "Form Ability A", + "launchType": "standard", + "orientation": "unspecified", + "type": "page", + "visible": true, + "skills": [ + { + "actions": [ + "ohos.aafwk.content.Want.ACTION_HOME" + ], + "entities": [ + "ohos.aafwk.content.Want.ENTITY_HOME" + ], + "attributes": [] + } + ] + }], + "defPermissions": [ + { + "name": "ohos.permission.REQUIRE_FORM", + "grantMode": "system_grant", + "label": "$string:entry_MainAbility", + "description": "REQUIRE_FORM permission in detail" + } + ], + "reqPermissions": [ + { + "name": "ohos.permission.REQUIRE_FORM", + "reason": "fmsStressTest100", + "usedScene": { + "ability": [ + ".MainAbility" + ], + "when": "always" + } + } + ], + "js": [ + { + "name": "formDemo", + "pages": [ + "pages/index/index" + ], + "type": "form" + } + ] + } +} \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNotSys/include/form_ability_not_sys.h b/test/resource/formsystemtestability/fmsSystemTestHostNotSys/include/form_ability_not_sys.h new file mode 100644 index 0000000000..b3c31ad84c --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNotSys/include/form_ability_not_sys.h @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _FORM_ABILITY_A_H_ +#define _FORM_ABILITY_A_H_ +#include "ability_loader.h" +#include "common_event.h" +#include "common_event_manager.h" + +namespace OHOS { +namespace AppExecFwk { +class FormEventSubscriber; +class FormAbilityNotSys : public Ability { +public: + void SubscribeEvent(const std::vector &eventList); + void handleEvent(std::string action); + + void FMS_acquireForm_0100(); + void FMS_deleteForm_0100(); + void FMS_releaseForm_0100(); + + std::shared_ptr subscriber_; + + class AcquireFormCallback : public FormCallback { + public: + AcquireFormCallback(std::string name):caseName_(name) + { + } + virtual ~AcquireFormCallback() = default; + void OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const override; + void OnFormUninstall(const int64_t formId) const override; + + std::string caseName_; + }; +protected: + virtual void Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) override; + virtual void OnStart(const Want &want) override; + virtual void OnStop() override; + virtual void OnActive() override; + virtual void OnInactive() override; + virtual void OnBackground() override; +private: + void Clear(); + + using FormFunc = void (FormAbilityNotSys::*)(); + std::map memberFuncMap_; + +}; + +class FormEventSubscriber : public EventFwk::CommonEventSubscriber { +public: + FormEventSubscriber(const EventFwk::CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp) + { + ability_ = nullptr; + } + ~FormEventSubscriber() + { + ability_ = nullptr; + } + virtual void OnReceiveEvent(const EventFwk::CommonEventData &data) override; + void KitTerminateAbility(); + + FormAbilityNotSys *ability_; +}; +} // namespace AppExecFwk +} // namespace OHOS +#endif // _FORM_ABILITY_A_H_ \ No newline at end of file diff --git a/test/resource/formsystemtestability/fmsSystemTestHostNotSys/src/form_ability_not_sys.cpp b/test/resource/formsystemtestability/fmsSystemTestHostNotSys/src/form_ability_not_sys.cpp new file mode 100644 index 0000000000..818bde839c --- /dev/null +++ b/test/resource/formsystemtestability/fmsSystemTestHostNotSys/src/form_ability_not_sys.cpp @@ -0,0 +1,183 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "app_log_wrapper.h" +#include "form_ability_not_sys.h" +#include +#include +#include +#include "form_test_utils.h" +#include "form_st_common_info.h" + +namespace { +using namespace OHOS::AAFwk; +using namespace OHOS::EventFwk; +} + +namespace OHOS { +namespace AppExecFwk { +void FormAbilityNotSys::AcquireFormCallback::OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called", __func__); +} +void FormAbilityNotSys::AcquireFormCallback::OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const +{ + APP_LOGI("%{public}s called", __func__); +} +void FormAbilityNotSys::AcquireFormCallback::OnFormUninstall(const int64_t formId) const +{ + APP_LOGI("%{public}s called", __func__); +} +void FormAbilityNotSys::FMS_acquireForm_0100() +{ + std::shared_ptr callback = std::make_shared("FMS_acquireForm_0100"); + // Set Want info begin + Want want; + want.SetParam(Constants::PARAM_FORM_DIMENSION_KEY, FORM_DIMENSION_1); + want.SetParam(Constants::PARAM_FORM_NAME_KEY, PARAM_FORM_NAME1); + want.SetParam(Constants::PARAM_MODULE_NAME_KEY, PARAM_PROVIDER_MODULE_NAME1); + want.SetParam(Constants::PARAM_FORM_TEMPORARY_KEY, FORM_TEMP_FORM_FLAG_FALSE); + want.SetElementName(FORM_TEST_DEVICEID, FORM_PROVIDER_BUNDLE_NAME1, FORM_PROVIDER_ABILITY_NAME1); + // Set Want info end + bool bResult = AcquireForm(0, want, callback); + if(bResult) { + APP_LOGI("AcquireForm end"); + } else { + APP_LOGE("AcquireForm error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_ACQUIRE_FORM_0100, 100, "false"); + } +} + +void FormAbilityNotSys::FMS_deleteForm_0100() +{ + int64_t formId = 1; + bool bResult = DeleteForm(formId); + if(bResult) { + APP_LOGI("[FMS_deleteForm_0100] end"); + } else { + APP_LOGE("[FMS_deleteForm_0100] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_DELETE_FORM_0100, 100, "false"); + } +} + +void FormAbilityNotSys::FMS_releaseForm_0100() +{ + int64_t formId = 1; + bool isReleaseCache = true; + bool bResult = ReleaseForm(formId, isReleaseCache); + if(bResult) { + APP_LOGI("[FMS_releaseForm_0100] end"); + } else { + APP_LOGE("[FMS_releaseForm_0100] error"); + FormTestUtils::PublishEvent(FORM_EVENT_RECV_RELEASE_FORM_0100, 100, "false"); + } +} + +void FormAbilityNotSys::OnStart(const Want &want) +{ + APP_LOGI("FormAbilityNotSys::onStart"); + Ability::OnStart(want); + + std::vector eventList = { + FORM_EVENT_REQ_ACQUIRE_FORM_0100, + FORM_EVENT_REQ_DELETE_FORM_0100, + FORM_EVENT_REQ_RELEASE_FORM_0100, + }; + SubscribeEvent(eventList); +} +void FormAbilityNotSys::OnActive() +{ + APP_LOGI("FormAbilityNotSys::OnActive"); + Ability::OnActive(); + std::string eventData = GetAbilityName() + FORM_ABILITY_STATE_ONACTIVE; + FormTestUtils::PublishEvent(FORM_EVENT_ABILITY_ONACTIVED, 0, eventData); +} + +void FormAbilityNotSys::OnStop() +{ + APP_LOGI("FormAbilityNotSys::OnStop"); + + Ability::OnStop(); +} +void FormAbilityNotSys::OnInactive() +{ + APP_LOGI("FormAbilityNotSys::OnInactive"); + + Ability::OnInactive(); +} +void FormAbilityNotSys::OnBackground() +{ + APP_LOGI("FormAbilityNotSys::OnBackground"); + + Ability::OnBackground(); +} +void FormAbilityNotSys::SubscribeEvent(const std::vector &eventList) +{ + MatchingSkills matchingSkills; + for (const auto &e : eventList) { + matchingSkills.AddEvent(e); + } + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + subscribeInfo.SetPriority(1); + subscriber_ = std::make_shared(subscribeInfo); + subscriber_->ability_ = this; + CommonEventManager::SubscribeCommonEvent(subscriber_); +} + +// KitTest End +void FormAbilityNotSys::Init(const std::shared_ptr &abilityInfo, + const std::shared_ptr &application, std::shared_ptr &handler, + const sptr &token) +{ + APP_LOGI("FormAbilityNotSys::Init"); + Ability::Init(abilityInfo, application, handler, token); + + memberFuncMap_[FORM_EVENT_REQ_ACQUIRE_FORM_0100] = &FormAbilityNotSys::FMS_acquireForm_0100; + memberFuncMap_[FORM_EVENT_REQ_DELETE_FORM_0100] = &FormAbilityNotSys::FMS_deleteForm_0100; + memberFuncMap_[FORM_EVENT_REQ_RELEASE_FORM_0100] = &FormAbilityNotSys::FMS_releaseForm_0100; +} + +void FormAbilityNotSys::handleEvent(std::string action) +{ + auto itFunc = memberFuncMap_.find(action); + if (itFunc != memberFuncMap_.end()) { + auto memberFunc = itFunc->second; + if (memberFunc != nullptr) { + return (this->*memberFunc)(); + } + } +} + +void FormAbilityNotSys::Clear() +{ +} + +void FormEventSubscriber::OnReceiveEvent(const CommonEventData &data) +{ + APP_LOGI("FormEventSubscriber::OnReceiveEvent:event=%{public}s", data.GetWant().GetAction().c_str()); + APP_LOGI("FormEventSubscriber::OnReceiveEvent:code=%{public}d", data.GetCode()); + auto eventName = data.GetWant().GetAction(); + ability_->handleEvent(eventName); +} + +void FormEventSubscriber::KitTerminateAbility() +{ + if (ability_ != nullptr) { + ability_->TerminateAbility(); + } +} + +REGISTER_AA(FormAbilityNotSys) +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/resource/formsystemtestability/tool/include/form_test_utils.h b/test/resource/formsystemtestability/tool/include/form_test_utils.h new file mode 100644 index 0000000000..6c58f392ce --- /dev/null +++ b/test/resource/formsystemtestability/tool/include/form_test_utils.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef _FORM_TEST_UTILS_H_ +#define _FORM_TEST_UTILS_H_ +#include "ability_info.h" +#include "ability_lifecycle.h" +#include "application_info.h" +#include "process_info.h" +#include "want.h" + +namespace OHOS { +namespace AppExecFwk { +const int OnStateChangedEventWant = LifeCycle::Event::UNDEFINED; +const int OnStateChangedEvent = (int)LifeCycle::Event::UNDEFINED + 1; +const int requestCodeForTerminate = 10; +const int requestCodeForResult = 20; + +class FormTestUtils { +public: + FormTestUtils() = default; + virtual ~FormTestUtils() = default; + static bool PublishEvent(const std::string &eventName, const int &code, const std::string &data); + static Want MakeWant(std::string deviceId, std::string abilityName, std::string bundleName, + std::map params); + static std::vector split(const std::string &in, const std::string &delim); +}; +} // namespace AppExecFwk +} // namespace OHOS +#endif // _FORM_TEST_UTILS_H_ \ No newline at end of file diff --git a/test/resource/formsystemtestability/tool/src/form_test_utils.cpp b/test/resource/formsystemtestability/tool/src/form_test_utils.cpp new file mode 100644 index 0000000000..a0075418a7 --- /dev/null +++ b/test/resource/formsystemtestability/tool/src/form_test_utils.cpp @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "form_test_utils.h" +#include +#include +#include +#include +#include "common_event_data.h" +#include "common_event_manager.h" +namespace OHOS { +namespace AppExecFwk { +using namespace OHOS::EventFwk; +bool FormTestUtils::PublishEvent(const std::string &eventName, const int &code, const std::string &data) +{ + Want want; + want.SetAction(eventName); + CommonEventData commonData; + commonData.SetWant(want); + commonData.SetCode(code); + commonData.SetData(data); + return CommonEventManager::PublishCommonEvent(commonData); +} + +Want FormTestUtils::MakeWant( + std::string deviceId, std::string abilityName, std::string bundleName, std::map params) +{ + ElementName element(deviceId, bundleName, abilityName); + Want want; + want.SetElement(element); + for (const auto ¶m : params) { + want.SetParam(param.first, param.second); + } + return want; +} + +std::vector FormTestUtils::split(const std::string &in, const std::string &delim) +{ + std::regex reg(delim); + std::vector res = { + std::sregex_token_iterator(in.begin(), in.end(), reg, -1), std::sregex_token_iterator() + }; + return res; +} +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/systemtest/BUILD.gn b/test/systemtest/BUILD.gn index 9865e4bf44..ad06723297 100755 --- a/test/systemtest/BUILD.gn +++ b/test/systemtest/BUILD.gn @@ -26,6 +26,7 @@ group("systemtest") { "common/ams:systemtest", "common/bms:systemtest_bms", "common/ems:systemtest_ems", + "common/fms:systemtest", "common/task_dispatcher:systemtest_task", ] } diff --git a/test/systemtest/common/fms/BUILD.gn b/test/systemtest/common/fms/BUILD.gn new file mode 100755 index 0000000000..5e528780d3 --- /dev/null +++ b/test/systemtest/common/fms/BUILD.gn @@ -0,0 +1,42 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") +import("//foundation/appexecfwk/standard/appexecfwk.gni") + +config("form_manager_test_config") { + defines = [ + "APP_LOG_TAG = \"FormManagerTest\"", + "LOG_DOMAIN = 0xD00666F", + ] + + configs = [ + "${aafwk_path}/frameworks/kits/ability/native:ability_config", + "${appexecfwk_path}/interfaces/innerkits/appexecfwk_base:appexecfwk_base_sdk_config", + ] +} + +public_configs = [ ":form_manager_test_config" ] + +group("systemtest") { + testonly = true + + deps = [ + "fms_acquire_form_test:systemtest", + "fms_delete_form_test:systemtest", + "fms_fuzz_test:systemtest", + "fms_performance_test:systemtest", + "fms_release_form_test:systemtest", + "fms_stress_test:systemtest", + ] +} diff --git a/test/systemtest/common/fms/common/include/form_event.h b/test/systemtest/common/fms/common/include/form_event.h new file mode 100644 index 0000000000..5609149115 --- /dev/null +++ b/test/systemtest/common/fms/common/include/form_event.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef OHOS_SYSTEM_TEST_FMS_STEVENT_H +#define OHOS_SYSTEM_TEST_FMS_STEVENT_H + +#include +#include +#include +#include +#include +#include +#include "hilog_wrapper.h" +namespace OHOS { +namespace STtools { +class FormEvent { +public: + FormEvent(); + ~FormEvent(); + bool Compare(); + int WaitingMessage(const std::string &message, int timeout_ms, bool locked); + void CompleteMessage(const std::string &message); + void Clean(); + std::string GetData(const std::string &message); + void CompleteMessage(const std::string &message, const std::string &data); + +private: + std::mutex mutex_; + std::condition_variable cv_; + std::string waiting_message_; + std::vector complete_message_; + std::unordered_map message_data_; +}; +} // namespace STtools +} // namespace OHOS +#endif // OHOS_SYSTEM_TEST_FMS_STEVENT_H \ No newline at end of file diff --git a/test/systemtest/common/fms/common/include/form_st_common_info.h b/test/systemtest/common/fms/common/include/form_st_common_info.h new file mode 100644 index 0000000000..92f898c37a --- /dev/null +++ b/test/systemtest/common/fms/common/include/form_st_common_info.h @@ -0,0 +1,248 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef FORM_ST_COMMON_INFO_H +#define FORM_ST_COMMON_INFO_H + +namespace OHOS { +namespace AppExecFwk { +const std::string PERMISSION_NAME_REQUIRE_FORM = "ohos.permission.REQUIRE_FORM"; +const std::string FORM_TEST_DEVICEID = "0"; + +const std::string FORM_ABILITY_STATE_ONACTIVE = ":OnActive"; +const std::string FORM_EVENT_ABILITY_ONACTIVED = "fms_req_acquireForm_ability_actived"; + +const int FORM_DIMENSION_1 = 1; +const bool FORM_TEMP_FORM_FLAG_FALSE = false; +const bool FORM_TEMP_FORM_FLAG_TRUE = true; + +// provider ability +const std::string FORM_PROVIDER_BUNDLE_NAME1 = "com.form.formsystemtestservicea"; +const std::string PARAM_PROVIDER_MODULE_NAME1 = "formmodule001"; +const std::string FORM_PROVIDER_ABILITY_NAME1 = "com.form.formmodule001.FormAbility001"; +const std::string PARAM_FORM_NAME1 = "Form_Js001"; + +const std::string FORM_PROVIDER_BUNDLE_NAME2 = "com.form.formsystemtestserviceb"; +const std::string PARAM_PROVIDER_MODULE_NAME2 = "formmodule001"; +const std::string FORM_PROVIDER_ABILITY_NAME2 = "com.form.formmodule001.FormAbility001"; +const std::string PARAM_FORM_NAME2 = "Form_Js001"; + + +//add Form +const std::string FORM_EVENT_RECV_DELETE_FORM_COMMON = "fms_recv_deleteForm_common"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_0100 = "fms_req_acquireForm_0100"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_0100 = "fms_recv_acquireForm_0100"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_0200 = "fms_req_acquireForm_0200"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_0200 = "fms_recv_acquireForm_0200"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_0300 = "fms_req_acquireForm_0300"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_0300 = "fms_recv_acquireForm_0300"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_0400 = "fms_req_acquireForm_0400"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_0400 = "fms_recv_acquireForm_0400"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_0500 = "fms_req_acquireForm_0500"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_0500 = "fms_recv_acquireForm_0500"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_0600 = "fms_req_acquireForm_0600"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_0600 = "fms_recv_acquireForm_0600"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_0700 = "fms_req_acquireForm_0700"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_0700 = "fms_recv_acquireForm_0700"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_1000 = "fms_req_acquireForm_1000"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_1000 = "fms_recv_acquireForm_1000"; + +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_1100 = "fms_req_acquireForm_1100"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_1100 = "fms_recv_acquireForm_1100"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_1200 = "fms_req_acquireForm_1200"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_1200 = "fms_recv_acquireForm_1200"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_1400 = "fms_req_acquireForm_1400"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_1400 = "fms_recv_acquireForm_1400"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_1400_1 = "fms_req_acquireForm_1400_1"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_1400_1 = "fms_recv_acquireForm_1400_1"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_1500 = "fms_req_acquireForm_1500"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_1500 = "fms_recv_acquireForm_1500"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_1500_1 = "fms_req_acquireForm_1500_1"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_1500_1 = "fms_recv_acquireForm_1500_1"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_1600 = "fms_req_acquireForm_1600"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_1600 = "fms_recv_acquireForm_1600"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_1600_1 = "fms_req_acquireForm_1600_1"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_1600_1 = "fms_recv_acquireForm_1600_1"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_1800 = "fms_req_acquireForm_1800"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_1800 = "fms_recv_acquireForm_1800"; + + +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_1800_1 = "fms_req_acquireForm_1800_1"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_1800_1 = "fms_recv_acquireForm_1800_1"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_1800_2 = "fms_req_acquireForm_1800_2"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_1800_2 = "fms_recv_acquireForm_1800_2"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_1800_3 = "fms_req_acquireForm_1800_3"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_1800_3 = "fms_recv_acquireForm_1800_3";const std::string FORM_EVENT_REQ_ACQUIRE_FORM_1900 = "fms_req_acquireForm_1900"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_1900 = "fms_recv_acquireForm_1900"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_2100 = "fms_req_acquireForm_2100"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_2100 = "fms_recv_acquireForm_2100"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_2100_1 = "fms_req_acquireForm_2100_1"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_2100_1 = "fms_recv_acquireForm_2100_1"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_2200 = "fms_req_acquireForm_2200"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_2200 = "fms_recv_acquireForm_2200"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_2300 = "fms_req_acquireForm_2300"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_2300 = "fms_recv_acquireForm_2300"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_2400 = "fms_req_acquireForm_2400"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_2400 = "fms_recv_acquireForm_2400"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_2500 = "fms_req_acquireForm_2500"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_2500 = "fms_recv_acquireForm_2500"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_2600 = "fms_req_acquireForm_2600"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_2600 = "fms_recv_acquireForm_2600"; +const std::string FORM_EVENT_REQ_ACQUIRE_FORM_2600_1 = "fms_req_acquireForm_2600_1"; +const std::string FORM_EVENT_RECV_ACQUIRE_FORM_2600_1 = "fms_recv_acquireForm_2600_1"; + +//Delete Form +const std::string FORM_EVENT_REQ_DELETE_FORM_0100 = "fms_req_deleteForm_0100"; +const std::string FORM_EVENT_RECV_DELETE_FORM_0100 = "fms_recv_deleteForm_0100"; +const std::string FORM_EVENT_REQ_DELETE_FORM_0200 = "fms_req_deleteForm_0200"; +const std::string FORM_EVENT_RECV_DELETE_FORM_0200 = "fms_recv_deleteForm_0200"; +const std::string FORM_EVENT_REQ_DELETE_FORM_0300 = "fms_req_deleteForm_0300"; +const std::string FORM_EVENT_RECV_DELETE_FORM_0300 = "fms_recv_deleteForm_0300"; +const std::string FORM_EVENT_REQ_DELETE_FORM_0400 = "fms_req_deleteForm_0400"; +const std::string FORM_EVENT_RECV_DELETE_FORM_0400 = "fms_recv_deleteForm_0400"; +const std::string FORM_EVENT_REQ_DELETE_FORM_0500 = "fms_req_deleteForm_0500"; +const std::string FORM_EVENT_RECV_DELETE_FORM_0500 = "fms_recv_deleteForm_0500"; +const std::string FORM_EVENT_REQ_DELETE_FORM_0600 = "fms_req_deleteForm_0600"; +const std::string FORM_EVENT_RECV_DELETE_FORM_0600 = "fms_recv_deleteForm_0600"; +const std::string FORM_EVENT_REQ_DELETE_FORM_0700 = "fms_req_deleteForm_0700"; +const std::string FORM_EVENT_RECV_DELETE_FORM_0700 = "fms_recv_deleteForm_0700"; +const std::string FORM_EVENT_REQ_DELETE_FORM_0800 = "fms_req_deleteForm_0800"; +const std::string FORM_EVENT_RECV_DELETE_FORM_0800 = "fms_recv_deleteForm_0800"; +const std::string FORM_EVENT_REQ_DELETE_FORM_0900 = "fms_req_deleteForm_0900"; +const std::string FORM_EVENT_RECV_DELETE_FORM_0900 = "fms_recv_deleteForm_0900"; +const std::string FORM_EVENT_REQ_DELETE_FORM_1000 = "fms_req_deleteForm_1000"; +const std::string FORM_EVENT_RECV_DELETE_FORM_1000 = "fms_recv_deleteForm_1000"; +const std::string FORM_EVENT_REQ_DELETE_FORM_1100 = "fms_req_deleteForm_1100"; +const std::string FORM_EVENT_RECV_DELETE_FORM_1100 = "fms_recv_deleteForm_1100"; +const std::string FORM_EVENT_REQ_DELETE_FORM_1200 = "fms_req_deleteForm_1200"; +const std::string FORM_EVENT_RECV_DELETE_FORM_1200 = "fms_recv_deleteForm_1200"; +const std::string FORM_EVENT_REQ_DELETE_FORM_1400 = "fms_req_deleteForm_1400"; +const std::string FORM_EVENT_RECV_DELETE_FORM_1400 = "fms_recv_deleteForm_1400"; +const std::string FORM_EVENT_REQ_DELETE_FORM_1500 = "fms_req_deleteForm_1500"; +const std::string FORM_EVENT_RECV_DELETE_FORM_1500 = "fms_recv_deleteForm_1500"; +const std::string FORM_EVENT_REQ_DELETE_FORM_1600 = "fms_req_deleteForm_1600"; +const std::string FORM_EVENT_RECV_DELETE_FORM_1600 = "fms_recv_deleteForm_1600"; +const std::string FORM_EVENT_REQ_DELETE_FORM_1700 = "fms_req_deleteForm_1700"; +const std::string FORM_EVENT_RECV_DELETE_FORM_1700 = "fms_recv_deleteForm_1700"; + +//Release Form +const std::string FORM_EVENT_REQ_RELEASE_FORM_0100 = "fms_req_releaseForm_0100"; +const std::string FORM_EVENT_RECV_RELEASE_FORM_0100 = "fms_recv_releaseForm_0100"; +const std::string FORM_EVENT_REQ_RELEASE_FORM_0200 = "fms_req_releaseForm_0200"; +const std::string FORM_EVENT_RECV_RELEASE_FORM_0200 = "fms_recv_releaseForm_0200"; +const std::string FORM_EVENT_REQ_RELEASE_FORM_0300 = "fms_req_releaseForm_0300"; +const std::string FORM_EVENT_RECV_RELEASE_FORM_0300 = "fms_recv_releaseForm_0300"; +const std::string FORM_EVENT_REQ_RELEASE_FORM_0400 = "fms_req_releaseForm_0400"; +const std::string FORM_EVENT_RECV_RELEASE_FORM_0400 = "fms_recv_releaseForm_0400"; +const std::string FORM_EVENT_REQ_RELEASE_FORM_0500 = "fms_req_releaseForm_0500"; +const std::string FORM_EVENT_RECV_RELEASE_FORM_0500 = "fms_recv_releaseForm_0500"; +const std::string FORM_EVENT_REQ_RELEASE_FORM_0600 = "fms_req_releaseForm_0600"; +const std::string FORM_EVENT_RECV_RELEASE_FORM_0600 = "fms_recv_releaseForm_0600"; +const std::string FORM_EVENT_REQ_RELEASE_FORM_0700 = "fms_req_releaseForm_0700"; +const std::string FORM_EVENT_RECV_RELEASE_FORM_0700 = "fms_recv_releaseForm_0700"; +const std::string FORM_EVENT_REQ_RELEASE_FORM_0800 = "fms_req_releaseForm_0800"; +const std::string FORM_EVENT_RECV_RELEASE_FORM_0800 = "fms_recv_releaseForm_0800"; +const std::string FORM_EVENT_REQ_RELEASE_FORM_0900 = "fms_req_releaseForm_0900"; +const std::string FORM_EVENT_RECV_RELEASE_FORM_0900 = "fms_recv_releaseForm_0900"; +const std::string FORM_EVENT_REQ_RELEASE_FORM_1000 = "fms_req_releaseForm_1000"; +const std::string FORM_EVENT_RECV_RELEASE_FORM_1000 = "fms_recv_releaseForm_1000"; +const std::string FORM_EVENT_REQ_RELEASE_FORM_1100 = "fms_req_releaseForm_1100"; +const std::string FORM_EVENT_RECV_RELEASE_FORM_1100 = "fms_recv_releaseForm_1100"; +const std::string FORM_EVENT_REQ_RELEASE_FORM_1200 = "fms_req_releaseForm_1200"; +const std::string FORM_EVENT_RECV_RELEASE_FORM_1200 = "fms_recv_releaseForm_1200"; +const std::string FORM_EVENT_REQ_RELEASE_FORM_1300 = "fms_req_releaseForm_1300"; +const std::string FORM_EVENT_RECV_RELEASE_FORM_1300 = "fms_recv_releaseForm_1300"; +const std::string FORM_EVENT_REQ_RELEASE_FORM_1400 = "fms_req_releaseForm_1400"; +const std::string FORM_EVENT_RECV_RELEASE_FORM_1400 = "fms_recv_releaseForm_1400"; + +//Stress Test +const std::string FORM_EVENT_REQ_STRESS_TEST_0100 = "fms_req_stressTest_0100"; +const std::string FORM_EVENT_RECV_STRESS_TEST_0100 = "fms_recv_stressTest_0100"; +const std::string FORM_EVENT_REQ_STRESS_TEST_0100_01 = "fms_req_stressTest_0100_01"; +const std::string FORM_EVENT_RECV_STRESS_TEST_0100_01 = "fms_recv_stressTest_0100_01"; +const std::string FORM_EVENT_REQ_STRESS_TEST_0200 = "fms_req_stressTest_0200"; +const std::string FORM_EVENT_RECV_STRESS_TEST_0200 = "fms_recv_stressTest_0200"; +const std::string FORM_EVENT_REQ_STRESS_TEST_0200_01 = "fms_req_stressTest_0200_01"; +const std::string FORM_EVENT_RECV_STRESS_TEST_0200_01 = "fms_recv_stressTest_0200_01"; +const std::string FORM_EVENT_REQ_STRESS_TEST_0200_02 = "fms_req_stressTest_0200_02"; +const std::string FORM_EVENT_RECV_STRESS_TEST_0200_02 = "fms_recv_stressTest_0200_02"; +const std::string FORM_EVENT_REQ_STRESS_TEST_0200_03 = "fms_req_stressTest_0200_03"; +const std::string FORM_EVENT_RECV_STRESS_TEST_0200_03 = "fms_recv_stressTest_0200_03"; +const std::string FORM_EVENT_REQ_STRESS_TEST_0300 = "fms_req_stressTest_0300"; +const std::string FORM_EVENT_RECV_STRESS_TEST_0300 = "fms_recv_stressTest_0300"; +const std::string FORM_EVENT_REQ_STRESS_TEST_0300_01 = "fms_req_stressTest_0300_01"; +const std::string FORM_EVENT_RECV_STRESS_TEST_0300_01 = "fms_recv_stressTest_0300_01"; +const std::string FORM_EVENT_REQ_STRESS_TEST_0300_02 = "fms_req_stressTest_0300_02"; +const std::string FORM_EVENT_RECV_STRESS_TEST_0300_02 = "fms_recv_stressTest_0300_02"; +const std::string FORM_EVENT_REQ_STRESS_TEST_0400 = "fms_req_stressTest_0400"; +const std::string FORM_EVENT_RECV_STRESS_TEST_0400 = "fms_recv_stressTest_0400"; +const std::string FORM_EVENT_REQ_STRESS_TEST_0500 = "fms_req_stressTest_0500"; +const std::string FORM_EVENT_RECV_STRESS_TEST_0500 = "fms_recv_stressTest_0500"; +const std::string FORM_EVENT_REQ_STRESS_TEST_1100 = "fms_req_stressTest_1100"; +const std::string FORM_EVENT_RECV_STRESS_TEST_1100 = "fms_recv_stressTest_1100"; +const std::string FORM_EVENT_REQ_STRESS_TEST_1100_01 = "fms_req_stressTest_1100_01"; +const std::string FORM_EVENT_RECV_STRESS_TEST_1100_01 = "fms_recv_stressTest_1100_01"; +const std::string FORM_EVENT_REQ_STRESS_TEST_1100_02 = "fms_req_stressTest_1100_02"; +const std::string FORM_EVENT_RECV_STRESS_TEST_1100_02 = "fms_recv_stressTest_1100_02"; +const std::string FORM_EVENT_REQ_STRESS_TEST_1100_03 = "fms_req_stressTest_1100_03"; +const std::string FORM_EVENT_RECV_STRESS_TEST_1100_03 = "fms_recv_stressTest_1100_03"; +const std::string FORM_EVENT_REQ_STRESS_TEST_1300 = "fms_req_stressTest_1300"; +const std::string FORM_EVENT_RECV_STRESS_TEST_1300 = "fms_recv_stressTest_1300"; +const std::string FORM_EVENT_REQ_STRESS_TEST_1300_01 = "fms_req_stressTest_1300_01"; +const std::string FORM_EVENT_RECV_STRESS_TEST_1300_01 = "fms_recv_stressTest_1300_01"; +const std::string FORM_EVENT_REQ_STRESS_TEST_1300_02 = "fms_req_stressTest_1300_02"; +const std::string FORM_EVENT_RECV_STRESS_TEST_1300_02 = "fms_recv_stressTest_1300_02"; +const std::string FORM_EVENT_REQ_STRESS_TEST_1300_03 = "fms_req_stressTest_1300_03"; +const std::string FORM_EVENT_RECV_STRESS_TEST_1300_03 = "fms_recv_stressTest_1300_03"; +const std::string FORM_EVENT_REQ_STRESS_TEST_1700 = "fms_req_stressTest_1700"; +const std::string FORM_EVENT_RECV_STRESS_TEST_1700 = "fms_recv_stressTest_1700"; +const std::string FORM_EVENT_REQ_STRESS_TEST_1700_01 = "fms_req_stressTest_1700_01"; +const std::string FORM_EVENT_RECV_STRESS_TEST_1700_01 = "fms_recv_stressTest_1700_01"; +const std::string FORM_EVENT_REQ_STRESS_TEST_1700_02 = "fms_req_stressTest_1700_02"; +const std::string FORM_EVENT_RECV_STRESS_TEST_1700_02 = "fms_recv_stressTest_1700_02"; +const std::string FORM_EVENT_REQ_STRESS_TEST_1800 = "fms_req_stressTest_1800"; +const std::string FORM_EVENT_RECV_STRESS_TEST_1800 = "fms_recv_stressTest_1800"; + +//CommonA(acquire one normal form) +const std::string FORM_EVENT_REQ_ONE_NORMAL_FORM = "fms_req_one_normal_form"; +const std::string FORM_EVENT_RECV_ONE_NORMAL_FORM = "fms_recv_one_normal_form"; + +//Performance Test +const std::string FORM_EVENT_REQ_PERFORMANCE_TEST_0100 = "fms_req_performanceTest_0100"; +const std::string FORM_EVENT_RECV_PERFORMANCE_TEST_0100 = "fms_recv_performanceTest_0100"; +const std::string FORM_EVENT_REQ_PERFORMANCE_TEST_0200 = "fms_req_performanceTest_0200"; +const std::string FORM_EVENT_RECV_PERFORMANCE_TEST_0200 = "fms_recv_performanceTest_0200"; +const std::string FORM_EVENT_REQ_PERFORMANCE_TEST_0300 = "fms_req_performanceTest_0300"; +const std::string FORM_EVENT_RECV_PERFORMANCE_TEST_0300 = "fms_recv_performanceTest_0300"; +const std::string FORM_EVENT_REQ_PERFORMANCE_TEST_0400 = "fms_req_performanceTest_0400"; +const std::string FORM_EVENT_RECV_PERFORMANCE_TEST_0400 = "fms_recv_performanceTest_0400"; +const std::string FORM_EVENT_REQ_PERFORMANCE_TEST_0500 = "fms_req_performanceTest_0500"; +const std::string FORM_EVENT_RECV_PERFORMANCE_TEST_0500 = "fms_recv_performanceTest_0500"; +const std::string FORM_EVENT_REQ_PERFORMANCE_TEST_0600 = "fms_req_performanceTest_0600"; +const std::string FORM_EVENT_RECV_PERFORMANCE_TEST_0600 = "fms_recv_performanceTest_0600"; +const std::string FORM_EVENT_REQ_PERFORMANCE_TEST_0700 = "fms_req_performanceTest_0700"; +const std::string FORM_EVENT_RECV_PERFORMANCE_TEST_0700 = "fms_recv_performanceTest_0700"; +const std::string FORM_EVENT_REQ_PERFORMANCE_TEST_1300 = "fms_req_performanceTest_1300"; +const std::string FORM_EVENT_RECV_PERFORMANCE_TEST_1300 = "fms_recv_performanceTest_1300"; +const std::string FORM_EVENT_REQ_PERFORMANCE_TEST_1400 = "fms_req_performanceTest_1400"; +const std::string FORM_EVENT_RECV_PERFORMANCE_TEST_1400 = "fms_recv_performanceTest_1400"; +const std::string FORM_EVENT_REQ_PERFORMANCE_TEST_1500 = "fms_req_performanceTest_1500"; +const std::string FORM_EVENT_RECV_PERFORMANCE_TEST_1500 = "fms_recv_performanceTest_1500"; +const std::string FORM_EVENT_REQ_PERFORMANCE_TEST_1600 = "fms_req_performanceTest_1600"; +const std::string FORM_EVENT_RECV_PERFORMANCE_TEST_1600 = "fms_recv_performanceTest_1600"; + +} // namespace AppExecFwk +} // namespace OHOS +#endif // FORM_ST_COMMON_INFO_H \ No newline at end of file diff --git a/test/systemtest/common/fms/common/include/form_st_dump_util.h b/test/systemtest/common/fms/common/include/form_st_dump_util.h new file mode 100644 index 0000000000..8cc2dba98f --- /dev/null +++ b/test/systemtest/common/fms/common/include/form_st_dump_util.h @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_FORM_ST_DUMP_UTIL_H +#define OHOS_FORM_ST_DUMP_UTIL_H + +#include +#include +#include +#include +#include +#include +#include + +namespace OHOS { +namespace STtools { +using str_vec = std::vector; +using str_iter = std::vector::iterator; +using dump_info_map = std::unordered_map; +using std::regex; +using std::string; + +class FormStDumpUtil { +public: + virtual ~FormStDumpUtil(); + static std::shared_ptr GetInstance(); + + /** + * + * @param {string} args : type to find + * @param {std::vector} dumpInfo : dump info + * @param {std::vector} results : all strings found that include @args + * @return {int} : size of @results + * @Introduction: Find all strings specified by @args in @dumpInfo and store them in @results. + */ + size_t GetAll(const string &args, const str_vec &dumpInfo, str_vec &results); + + /** + * + * @param {string} args : type to find + * @param {std::vector} dumpInfo : dump info + * @param {string} result : the first string found that includes @args + * @return {str_iter} : find or not + * @Introduction: Find the first string specified by @args in @dumpInfo and store it in @result. + */ + str_iter GetFirst(const string &args, const str_vec &dumpInfo, const str_iter &begin, string &result); + + /** + * + * @param {string} args : specific string to find + * @param {std::vector} dumpInfo : dump info + * @param {str_iter} begin : where to start searching + * @return {str_iter} : iter pointing to string containing @args + * @Introduction: Match the first @matchStr in @dumpInfo from @begin and return the iter. + */ + str_iter GetSpecific(const string &args, const str_vec &dumpInfo, const str_iter &begin); + + /** + * + * @param {str_vec} strVec_1 : the first vector of string + * @param {str_vec} strVec_2 : the second vector of string + * @return {bool} : the comparison result of the the params + * @Introduction: Return true if each item in @strVec_1 equals the corresponding one in @strVec_2. + */ + bool CompStrVec(const str_vec &strVec_1, const str_vec &strVec_2); + + /** + * + * @param {string} key : known type used to find info + * @param {string} value : value of the {key} + * @param {string} args : type to find + * @param {str_vec} dumpInfo : dump info + * @return {string} : string found in dumpInfo + * @Introduction: Return the value specified by @args with @key and @value in @dumpInfo. + */ + string GetBy(const string &key, const string &value, const string &args, const str_vec &dumpInfo); + + size_t GetBindingsByUri(const string &uri, const str_vec &dumpInfo, str_vec &result); + +private: + FormStDumpUtil(); + static std::mutex mutex_; + static std::shared_ptr instance_; + std::unordered_map findRgx_; + + inline bool MatchRegex(const regex ®ex, const string &str, string &result); +}; +} // namespace STtools +} // namespace OHOS +#endif // OHOS_FORM_ST_DUMP_UTIL_H diff --git a/test/systemtest/common/fms/common/include/form_st_operator.h b/test/systemtest/common/fms/common/include/form_st_operator.h new file mode 100644 index 0000000000..f1416b6e0c --- /dev/null +++ b/test/systemtest/common/fms/common/include/form_st_operator.h @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef OHOS_SYSTEM_TEST_ST_FROM_OPERATORTREE_H +#define OHOS_SYSTEM_TEST_ST_FROM_OPERATORTREE_H + +#include +#include +#include +#include + +namespace OHOS { +namespace STtools { +using std::string; + +class FormStOperator { +private: + std::vector> g_childOperator; + std::shared_ptr g_parentOperator; + string g_abilityType; + string g_bundleName; + string g_abilityName; + string g_operatorName; // data ability + string g_message; + /* data */ + static int countChild; + +public: + FormStOperator(); + FormStOperator(const string &type, const string &bundle, const string &ability, const string &operatorName = "", + const string &message = "r"); + ~FormStOperator(); + static int GetCountChild(); + string GetAbilityType(); + FormStOperator &SetAbilityType(const string &type); + string GetBundleName(); + FormStOperator &SetBundleName(const string &bundleName); + string GetAbilityName(); + FormStOperator &SetAbilityName(const string &abilityName); + string GetOperatorName(); + FormStOperator &SetOperatorName(const string &operatorName); + string GetMessage(); + FormStOperator &SetMessage(const string &message); + FormStOperator &AddChildOperator(std::shared_ptr childOperator); + std::vector> GetChildOperator(); +}; +} // namespace STtools +} // namespace OHOS +#endif // OHOS_SYSTEM_TEST_ST_FROM_OPERATORTREE_H \ No newline at end of file diff --git a/test/systemtest/common/fms/common/include/form_st_util.h b/test/systemtest/common/fms/common/include/form_st_util.h new file mode 100644 index 0000000000..371bf42059 --- /dev/null +++ b/test/systemtest/common/fms/common/include/form_st_util.h @@ -0,0 +1,365 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_SYSTEM_TEST_FORM_UTIL_H +#define OHOS_SYSTEM_TEST_FORM_UTIL_H + +#include +#include +#include +#include +#include + +#include "ability_manager_service.h" +#include "ability_manager_errors.h" +#include "app_mgr_service.h" +#include "bundle_installer_interface.h" +#include "bundle_mgr_interface.h" +#include "common_event.h" +#include "common_event_manager.h" +#include "form_event.h" +#include "form_mgr_interface.h" +#include "form_st_operator.h" +#include "form_st_dump_util.h" +#include "hilog_wrapper.h" +#include "iremote_proxy.h" +#include "sa_mgr_client.h" +#include "system_ability_definition.h" + +namespace OHOS { +namespace STtools { +namespace { +using vector_str = std::vector; +using MAP_STR_STR = std::map; +} // namespace +class SystemTestFormUtil { +public: + static std::shared_ptr GetInstance(); + static void DestroyInstance(); + ~SystemTestFormUtil() = default; + + /** + * + * @param {string} eventName : Sent FormEvent Name + * @param {int} code : Sent Code + * @param {string} data : Sent Data + * @Introduction: Sent FormEvent + */ + static bool PublishEvent(const std::string &eventName, const int &code, const std::string &data); + + /** + * + * @param {vector} hapNames : container containing multiple hap names + * @Introduction: use bm install multiple hap + */ + static void InstallHaps(vector_str &hapNames); + + /** + * + * @param {vector} bundleNames : container containing multiple bundle names + * @Introduction: use bm install multiple bundle + */ + static void UninstallBundle(vector_str &bundleNames); + + /** + * + * @param {string} serviceName : process name + * @Introduction: kill process + */ + static void KillService(const std::string &serviceName); + + /** + * + * @param {string} serviceName : executable file name + * @param {time_t} delay : Waiting time for executable to start(milliseconds) + * @Introduction: start executable file + */ + static void StartService(const std::string &serviceName, const time_t &delay = 0); + + /** + * + * @param {vector} bundleNames : Container Containing Multiple Bundle Names + * @Introduction: start executable file + */ + static void KillBundleProcess(vector_str &bundleNames); + + /** + * + * @Introduction: Get Ability manager Service. + */ + static sptr GetAbilityManagerService(); + + /** + * + * @Introduction: Get App manager Service. + */ + static sptr GetAppMgrService(); + + /** + * + * @param {Want} want : The want of the ability to start. + * @param {sptr} abilityMs : Ability Manager Service ptr + * @param {time_t} delay : Waiting time for ability to start (milliseconds) + * @Introduction: start ability + */ + static ErrCode StartAbility( + const AAFwk::Want &want, sptr &abilityMs, const time_t &delay = 0); + + /** + * + * @param {string} eventName : Sent FormEvent Name + * @param {int} code : Sent Code + * @param {string} data : Sent Data + * @Introduction: Sent FormEvent to terminate app + */ + static bool StopAbility(const std::string &eventName, const int &code, const std::string &data); + /** + * + * @param {string} deviceId : Device ID + * @param {string} abilityName : Ability Name + * @param {string} bundleName : Bundle Name + * @param {MAP_STR_STR} params : Params (SetParam) + * @Introduction: Great Want + */ + static AAFwk::Want MakeWant( + std::string deviceId, std::string abilityName, std::string bundleName, MAP_STR_STR params = {}); + + /** + * + * @param {string} deviceId : Device ID + * @param {string} abilityName : Ability Name + * @param {string} bundleName : Bundle Name + * @param {vector_str} params : Params (SetParam) + * @Introduction: Great Want + */ + static AAFwk::Want MakeWant( + std::string deviceId, std::string abilityName, std::string bundleName, vector_str params = {}); + + /** + * + * @param {int64_t} id : Ability Record ID + * @param {sptr} abilityMs : Ability Manager Service ptr + * @Introduction: Get Top AbilityRecord ID + */ + static ErrCode GetTopAbilityRecordId(int64_t &id, sptr &abilityMs); + + /** + * + * @param {shared_ptr} runningProcessInfo : Process Info + * @param {sptr} appMs : App Manager ptr + * @param {time_t} delay : Waiting time for ability to Get Process Info (milliseconds) + * @Introduction: Get Top AbilityRecord ID + */ + static ErrCode GetRunningProcessInfo(std::vector &runningProcessInfo, + sptr &appMs, const time_t &delay = 0); + + /** + * + * @param {string} appName : app Name + * @param {sptr} appMs : App Manager ptr + * @param {time_t} delay : Waiting time for ability to KillApplication (milliseconds) + * @Introduction: Get Top AbilityRecord ID + */ + static ErrCode KillApplication( + const std::string &appName, sptr &appMs, const time_t &delay = 0); + + /** + * + * @param {string} processName : processName + * @param {sptr} appMs : App Manager ptr + * @param {time_t} delay : Waiting time for ability to GetAppProcessInfo (milliseconds) + * @Introduction: Get Top AbilityRecord ID + */ + static AppExecFwk::RunningProcessInfo GetAppProcessInfoByName( + const std::string &processName, sptr &appMs, const time_t &delay = 0); + + /** + * + * @param {FormEvent} event : FormEvent Class Object + * @param {string} eventName : The name of the event to wait for. + * @param {int} code : The code of the event to wait for. + * @param {int} timeout : Time of wait (seconds) + * @Introduction: Judge whether the event is received in the event queue, if not, wait + */ + static int WaitCompleted( + STtools::FormEvent &event, const std::string &eventName, const int code, const int timeout = 15); + + /** + * + * @param {FormEvent} event : FormEvent Class Object + * @param {string} eventName : The name of the event to wait for. + * @param {int} code : The code of the event to wait for. + * @Introduction: Compare the received events, if not, join the event queue. + */ + static void Completed(STtools::FormEvent &event, const std::string &eventName, const int code); + + /** + * + * @param {FormEvent} event : FormEvent Class Object + * @param {string} eventName : The name of the event to wait for. + * @param {int} code : The code of the event to wait for. + * @param {string} data : The data of the event to wait for. + * @Introduction: Compare the received events, if not, join the event queue. + */ + static void Completed(STtools::FormEvent &event, const std::string &eventName, const int code, const std::string &data); + + /** + * + * @param {FormEvent} event : FormEvent Class Object + * @Introduction: Clean wait event. + */ + static void CleanMsg(STtools::FormEvent &event); + + /** + * + * @param {FormEvent} event : FormEvent Class Object + * @param {string} eventName : The name of the event to wait for. + * @param {int} code : The code of the event to wait for. + * @Introduction: get the event data. + */ + static std::string GetData(STtools::FormEvent &event, const std::string &eventName, const int code); + + /** + * + * @param {FormStOperator} ParentOperator : FormStOperator Class Object + * @Introduction: Serialization FormStOperator Class Object To Vector + */ + static std::vector SerializationStOperatorToVector(STtools::FormStOperator &ParentOperator); + + /** + * + * @param {FormStOperator} ParentOperator : FormStOperator Class Object + * @param {vector} vectorOperator : Data Source Resolved Into FormStOperator Class Object + * @Introduction: Deserialization FormStOperator Class Object From Vector + */ + static void DeserializationStOperatorFromVector( + STtools::FormStOperator &ParentOperator, std::vector &vectorOperator); + + /** + * + * @param {Want} want : The want of the ability to start. + * @param {sptr} connect : Callback + * @param {time_t} delay : Waiting time for ability to start (milliseconds) + * @Introduction: connect ability + */ + static ErrCode ConnectAbility(const AAFwk::Want &want, const sptr &connect, + const sptr &callerToken, unsigned int usec = 0); + + /** + * + * @param {Want} want : The want of the ability to start. + * @param {sptr} connect : Callback + * @param {time_t} delay : Waiting time for ability to start (milliseconds) + * @Introduction: disconnect ability + */ + static ErrCode DisconnectAbility(const sptr &connect, unsigned int usec = 0); + + /** + * + * @param {Want} want : The want of the ability to start. + * @param {time_t} delay : Waiting time for ability to start (milliseconds) + * @Introduction: stop service ability + */ + static ErrCode StopServiceAbility(const AAFwk::Want &want, unsigned int usec = 0); + + /** + * Remove the specified mission stack by stack id + * + * @param id. + * @param {sptr} abilityMs : Ability Manager Service ptr + * @param {time_t} delay : Waiting time for ability to GetAppProcessInfo (milliseconds) + * @return Returns ERR_OK on success, others on failure. + */ + static int RemoveStack(int id, sptr &abilityMs, const time_t &backHmoeDelay = 0, + const time_t &removeDelay = 0); + + /** + * + * @param {string} bundleFilePath : Hap File Name + * @param {AppExecFwk::InstallFlag} installFlag : install flag + * @Introduction: use bms install + */ + static void Install( + const std::string &bundleFilePath, const AppExecFwk::InstallFlag installFlag = AppExecFwk::InstallFlag::NORMAL); + + /** + * + * @param {string} bundleName : bundleName + * @Introduction: use bm uninstall bundleName + */ + static void Uninstall(const std::string &bundleName); + + /** + * @brief Query all of form storage infos. + * @return Returns all of form storage infos. + */ + static std::string QueryStorageFormInfos(); + /** + * @brief Query form infos by bundleName. + * @param bundleName BundleName. + * @return Returns form infos. + */ + static std::string QueryFormInfoByBundleName(const std::string& bundleName); + /** + * @brief Query form infos by form id. + * @param formId The id of the form. + * @return form infos. + */ + static std::string QueryFormInfoByFormId(const std::int64_t formId); +private: + /** + * + * @Introduction: get bundleManger object + */ + static sptr GetBundleMgrProxy(); + + /** + * + * @Introduction: get bundleInstaller object + */ + static sptr GetInstallerProxy(); + /** + * + * @param {vector} vectorOperator : FormStOperator Class Object Info Save in vectorOperator + * @param {FormStOperator} ParentOperator : FormStOperator Class Object + * @Introduction: push FormStOperator Class Object In Vector + */ + static void PushOperatorInVector(std::vector &vectorOperator, STtools::FormStOperator &ParentOperator); + + /** + * + * @param {FormStOperator} ParentOperator : FormStOperator Class Object + * @param {vector} vectorOperator : Data Source Resolved Into FormStOperator Class Object + * @Introduction: Pull FormStOperator Class Object From Vector + */ + SystemTestFormUtil() = default; + static void PullOperatorFromVector(STtools::FormStOperator &ParentOperator, std::vector &vectorOperator); + + /** + * @brief Get form manager service. + * @return Returns form manager servic remoteObject. + */ + static sptr GetFmsService(); + + static bool WriteInterfaceToken(MessageParcel &data); + static int GetStringInfo(AppExecFwk::IFormMgr::Message code, MessageParcel &data, std::string &stringInfo); + static int SendTransactCmd(AppExecFwk::IFormMgr::Message code, MessageParcel &data, MessageParcel &reply); + + static std::shared_ptr instance_; + static std::mutex mutex_; +}; +} // namespace STtools +} // namespace OHOS +#endif // OHOS_SYSTEM_TEST_FORM_UTIL_H diff --git a/test/systemtest/common/fms/common/src/form_event.cpp b/test/systemtest/common/fms/common/src/form_event.cpp new file mode 100644 index 0000000000..082058567e --- /dev/null +++ b/test/systemtest/common/fms/common/src/form_event.cpp @@ -0,0 +1,124 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "form_event.h" + +namespace OHOS { +namespace STtools { +FormEvent::FormEvent() +{ + waiting_message_ = ""; + complete_message_.clear(); +} + +FormEvent::~FormEvent() +{ + waiting_message_ = ""; + std::vector tmp_vector; + tmp_vector.swap(complete_message_); + complete_message_.clear(); +} + +bool FormEvent::Compare() +{ + if (!waiting_message_.empty()) { + for (size_t i = 0; i < complete_message_.size(); i++) { + if (waiting_message_.compare(complete_message_.at(i)) == 0) { + complete_message_.erase(std::begin(complete_message_) + i, std::begin(complete_message_) + i + 1); + waiting_message_ = ""; + return true; + } + } + } + return false; +} + +int FormEvent::WaitingMessage(const std::string &message, int timeout_ms, bool locked) +{ + std::unique_lock lock(mutex_); + HILOG_INFO(" WaitingMessage: [%{public}s]", message.c_str()); + waiting_message_ = message; + if (Compare()) { + HILOG_INFO(" WaitingMessage: unlock [%{public}s]", message.c_str()); + return 0; + } + + if (locked) { + HILOG_INFO(" WaitingMessage: locked [%{public}s]", message.c_str()); + cv_.wait(lock); + return 0; + } + + if (cv_.wait_for(lock, std::chrono::seconds(timeout_ms)) == std::cv_status::timeout) { + HILOG_INFO("[%{public}s] waiting timeout", waiting_message_.c_str()); + waiting_message_ = ""; + return -1; + } + return 0; +} + +void FormEvent::CompleteMessage(const std::string &message) +{ + std::unique_lock lock(mutex_); + HILOG_INFO("CompleteMessage [%{public}s]", message.c_str()); + if (waiting_message_.compare(message) == 0) { + HILOG_INFO("Completed unlocked: [%{public}s]", message.c_str()); + waiting_message_ = ""; + cv_.notify_all(); + return; + } + HILOG_INFO("completed message: [%{public}s] does not equal waiting message", message.c_str()); + + complete_message_.push_back(message); + return; +} + +void FormEvent::CompleteMessage(const std::string &message, const std::string &data) +{ + std::unique_lock lock(mutex_); + HILOG_INFO("CompleteMessage [%{public}s]", message.c_str()); + message_data_[message] = data; + if (waiting_message_.compare(message) == 0) { + HILOG_INFO("Completed unlocked: [%{public}s]", message.c_str()); + waiting_message_ = ""; + cv_.notify_all(); + return; + } + HILOG_INFO("completed message: [%{public}s] does not equal waiting message", message.c_str()); + + complete_message_.push_back(message); + return; +} + +std::string FormEvent::GetData(const std::string &message) +{ + std::string data; + std::unique_lock lock(mutex_); + if (message_data_.find(message) != message_data_.end()) { + data = message_data_.at(message); + message_data_.erase(message); + } + return data; +} + +void FormEvent::Clean() +{ + HILOG_INFO("FormEvent::Clean()"); + std::unique_lock lock(mutex_); + waiting_message_ = ""; + complete_message_.clear(); + message_data_.clear(); +} +} // namespace STtools +} // namespace OHOS \ No newline at end of file diff --git a/test/systemtest/common/fms/common/src/form_st_dump_util.cpp b/test/systemtest/common/fms/common/src/form_st_dump_util.cpp new file mode 100644 index 0000000000..5661364279 --- /dev/null +++ b/test/systemtest/common/fms/common/src/form_st_dump_util.cpp @@ -0,0 +1,161 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define private public +#include "form_st_dump_util.h" +#undef private + +namespace OHOS { +namespace STtools { +std::mutex FormStDumpUtil::mutex_; +std::shared_ptr FormStDumpUtil::instance_ = nullptr; +std::size_t matchSize = 2; +std::shared_ptr FormStDumpUtil::GetInstance() +{ + if (instance_ == nullptr) { + std::lock_guard lock_l(mutex_); + if (instance_ == nullptr) { + instance_ = std::make_shared(); + } + } + return instance_; +} + +FormStDumpUtil::FormStDumpUtil() +{ + findRgx_["Intent"] = regex(".*intent\\[(.+)\\].*"); + findRgx_["AbilityName"] = regex(".*main name \\[(.+)\\].*"); + findRgx_["AppName"] = regex(".*app name \\[(.+)\\].*"); + findRgx_["BundleName"] = regex(".*bundle name \\[(.+)\\].*"); + findRgx_["AbilityType"] = regex(".*ability type \\[(.+)\\].*"); + findRgx_["PreAbilityName"] = regex(".*previous ability app name \\[(.+)\\].*"); + findRgx_["PreAppName"] = regex(".*previous ability file name \\[(.+)\\].*"); + findRgx_["NextAbilityName"] = regex(".*next ability app name \\[(.+)\\].*"); + findRgx_["NextAppName"] = regex(".*next ability file name \\[(.+)\\].*"); + findRgx_["State"] = regex(".*state #(.+) .*"); + findRgx_["StartTime"] = regex(".*start time \\[(.+)\\].*"); + findRgx_["MissionRecordID"] = regex(".*MissionRecord ID #(.+) bottom app.*"); + findRgx_["MissionBottomApp"] = regex(".*bottom app \\[(.+)\\].*"); + findRgx_["UserID"] = regex(".*User ID #(.+)\\].*"); + findRgx_["MissionStackID"] = regex(".*MissionStack ID #(.+) \\[.*"); + findRgx_["Uri"] = regex(".*uri \\[(.+)\\].*"); + findRgx_["AbilityRecordID"] = regex(".*AbilityRecord ID #(.+) state.*"); + findRgx_["Bindings"] = regex(".+s: (\\d+).*"); + findRgx_["Component"] = regex(".*> (.+) .+#.+"); + findRgx_["BindState"] = regex(".*> .+/.+ #(.+)"); +} + +FormStDumpUtil::~FormStDumpUtil() +{ + instance_ = nullptr; + instance_.reset(); +} + +bool FormStDumpUtil::CompStrVec(const str_vec &strVec_1, const str_vec &strVec_2) +{ + if (strVec_1.size() != strVec_2.size()) { + return false; + } + for (unsigned int i = 0; i < strVec_1.size(); ++i) { + if (strVec_1[i].compare(strVec_2[i]) != 0) { + return false; + } + } + return true; +} + +str_iter FormStDumpUtil::GetSpecific(const string &matchStr, const str_vec &dumpInfo, const str_iter &begin) +{ + auto checkCondition = [&matchStr](const str_vec::value_type &value) -> bool { + return string::npos != value.find(matchStr); + }; + str_iter end; + std::advance(end, dumpInfo.size()); + return std::find_if(begin, end, checkCondition); +} + +bool FormStDumpUtil::MatchRegex(const regex &rgx, const string &text, string &result) +{ + std::smatch baseMatch; + if (std::regex_match(text, baseMatch, rgx)) { + if (baseMatch.size() == matchSize) { + result = baseMatch[1].str(); + return true; + } + } + return false; +} + +size_t FormStDumpUtil::GetAll(const string &args, const str_vec &dumpInfo, str_vec &results) +{ + results.clear(); + // args not exist + if (findRgx_.find(args) == findRgx_.end()) { + return 0; + } + string findResult; + for (const auto &info : dumpInfo) { + if (MatchRegex(findRgx_[args], info, findResult)) { + results.emplace_back(findResult); + } + } + return results.size(); +} + +str_iter FormStDumpUtil::GetFirst(const string &args, const str_vec &dumpInfo, const str_iter &begin, string &result) +{ + result.clear(); + str_iter end; + std::advance(end, dumpInfo.size()); + // args not exist + if (findRgx_.find(args) == findRgx_.end()) { + return end; + } + string findResult; + for (auto it = begin; it != dumpInfo.end(); ++it) { + if (MatchRegex(findRgx_[args], *it, findResult)) { + result = std::move(findResult); + return it; + } + } + return end; +} + +string FormStDumpUtil::GetBy(const string &key, const string &value, const string &args, const str_vec &dumpInfo) +{ + str_vec items; + size_t preSize = GetAll(key, dumpInfo, items); + auto iter = GetSpecific(value, items, items.begin()); + if (iter != items.end() && preSize == GetAll(args, dumpInfo, items)) { + return *iter; + } + return ""; +} + +size_t FormStDumpUtil::GetBindingsByUri(const string &uri, const str_vec &dumpInfo, str_vec &result) +{ + result.clear(); + str_vec dump(dumpInfo); + string bindings; + auto uriBegin = GetSpecific("uri [" + uri + "]", dump, dump.begin()); + auto bindingsBegin = GetFirst("Bindings", dump, uriBegin, bindings) + 1; + size_t ret = std::stoul("0" + bindings); + std::for_each(bindingsBegin, + (((bindingsBegin + ret) > dump.end()) ? (dump.end()) : (bindingsBegin + ret)), + [&result](auto &&it) { result.push_back(it); }); + return ret; +} +} // namespace STtools +} // namespace OHOS diff --git a/test/systemtest/common/fms/common/src/form_st_operator.cpp b/test/systemtest/common/fms/common/src/form_st_operator.cpp new file mode 100644 index 0000000000..cbb7a02925 --- /dev/null +++ b/test/systemtest/common/fms/common/src/form_st_operator.cpp @@ -0,0 +1,125 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "form_st_operator.h" + +namespace OHOS { +namespace STtools { +using std::string; + +int FormStOperator::countChild = 0; + +FormStOperator::FormStOperator() + : g_parentOperator(nullptr), g_abilityType("0"), g_bundleName(""), + g_abilityName(""), g_operatorName(""), g_message("") +{ + g_childOperator.clear(); + FormStOperator::countChild++; +} + +FormStOperator::FormStOperator( + const string &type, const string &bundle, const string &ability, const string &operatorName, const string &message) + : g_parentOperator(nullptr), + g_abilityType(type), + g_bundleName(bundle), + g_abilityName(ability), + g_operatorName(operatorName), + g_message(message) +{ + g_childOperator.clear(); + FormStOperator::countChild++; +} + +FormStOperator::~FormStOperator() +{ + g_childOperator.clear(); + FormStOperator::countChild--; +} + +int FormStOperator::GetCountChild() +{ + return FormStOperator::countChild; +} + +string FormStOperator::GetAbilityType() +{ + return g_abilityType; +} + +FormStOperator &FormStOperator::SetAbilityType(const string &type) +{ + g_abilityType = type; + return *this; +} + +string FormStOperator::GetBundleName() +{ + return g_bundleName; +} + +FormStOperator &FormStOperator::SetBundleName(const string &bundleName) +{ + g_bundleName = bundleName; + return *this; +} + +string FormStOperator::GetAbilityName() +{ + return g_abilityName; +} + +FormStOperator &FormStOperator::SetAbilityName(const string &abilityName) +{ + g_abilityName = abilityName; + return *this; +} + +string FormStOperator::GetOperatorName() +{ + return g_operatorName; +} + +FormStOperator &FormStOperator::SetOperatorName(const string &operatorName) +{ + g_operatorName = operatorName; + return *this; +} + +string FormStOperator::GetMessage() +{ + return g_message; +} + +FormStOperator &FormStOperator::SetMessage(const string &message) +{ + g_message = message; + return *this; +} + +FormStOperator &FormStOperator::AddChildOperator(std::shared_ptr childOperator) +{ + if (childOperator == nullptr) { + return *this; + } + childOperator->g_parentOperator = std::make_shared(*this); + g_childOperator.emplace_back(childOperator); + return *this; +} + +std::vector> FormStOperator::GetChildOperator() +{ + return g_childOperator; +} +} // namespace STtools +} // namespace OHOS \ No newline at end of file diff --git a/test/systemtest/common/fms/common/src/form_st_util.cpp b/test/systemtest/common/fms/common/src/form_st_util.cpp new file mode 100644 index 0000000000..70564f4a7f --- /dev/null +++ b/test/systemtest/common/fms/common/src/form_st_util.cpp @@ -0,0 +1,690 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "form_st_util.h" +#include "iservice_registry.h" +#include "status_receiver_host.h" + +namespace OHOS { +namespace STtools { +using namespace OHOS; +using namespace OHOS::AAFwk; +using namespace OHOS::AppExecFwk; +using namespace OHOS::EventFwk; + +std::mutex SystemTestFormUtil::mutex_; +std::shared_ptr SystemTestFormUtil::instance_ = nullptr; + +bool SystemTestFormUtil::PublishEvent(const std::string &eventName, const int &code, const std::string &data) +{ + Want want; + want.SetAction(eventName); + CommonEventData commonData; + commonData.SetWant(want); + commonData.SetCode(code); + commonData.SetData(data); + return CommonEventManager::PublishCommonEvent(commonData); +} + +void SystemTestFormUtil::InstallHaps(vector_str &hapNames) +{ + for (auto hapName : hapNames) { + Install(hapName); + } +} + +void SystemTestFormUtil::UninstallBundle(vector_str &bundleNames) +{ + for (auto bundleName : bundleNames) { + Uninstall(bundleName); + } +} + +void SystemTestFormUtil::KillService(const std::string &serviceName) +{ + system(("kill -9 $(pidof " + serviceName + ") > /dev/null 2>&1").c_str()); +} + +void SystemTestFormUtil::StartService(const std::string &serviceName, const time_t &delay) +{ + system(("/system/bin/" + serviceName + "& > /dev/null 2>&1").c_str()); + std::this_thread::sleep_for(std::chrono::milliseconds(delay)); +} + +void SystemTestFormUtil::KillBundleProcess(vector_str &bundleNames) +{ + for (std::string bundleName : bundleNames) { + KillService(bundleName); + } +} + +sptr SystemTestFormUtil::GetAbilityManagerService() +{ + sptr abilityMsObj = + OHOS::DelayedSingleton::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID); + if (abilityMsObj == nullptr) { + HILOG_ERROR("failed to get ability manager service"); + return nullptr; + } + return iface_cast(abilityMsObj); +} + +sptr SystemTestFormUtil::GetAppMgrService() +{ + sptr appMsObj = + OHOS::DelayedSingleton::GetInstance()->GetSystemAbility(APP_MGR_SERVICE_ID); + if (appMsObj == nullptr) { + HILOG_ERROR("failed to get app manager service"); + return nullptr; + } + return iface_cast(appMsObj); +} + +ErrCode SystemTestFormUtil::StartAbility(const Want &want, sptr &abilityMs, const time_t &delay) +{ + ErrCode result = OHOS::ERR_OK; + abilityMs = GetAbilityManagerService(); + if (abilityMs == nullptr) { + result = OHOS::ERR_INVALID_VALUE; + HILOG_ERROR("failed to get ability manager service"); + return result; + } + + result = abilityMs->StartAbility(want); + std::this_thread::sleep_for(std::chrono::milliseconds(delay)); + if (result == OHOS::ERR_OK) { + HILOG_INFO("start ability successfully."); + } else { + HILOG_INFO("failed to start ability."); + } + + return result; +} + +bool SystemTestFormUtil::StopAbility(const std::string &eventName, const int &code, const std::string &data) +{ + return PublishEvent(eventName, code, data); +} + +ErrCode SystemTestFormUtil::StopServiceAbility(const Want &want, unsigned int usec) +{ + ErrCode result = OHOS::ERR_OK; + + sptr abilityMs = GetAbilityManagerService(); + if (abilityMs == nullptr) { + result = OHOS::ERR_INVALID_VALUE; + HILOG_ERROR("failed to get ability manager service"); + return result; + } + + result = abilityMs->StopServiceAbility(want); + if (result == OHOS::ERR_OK) { + HILOG_INFO("stop service ability successfully."); + } else { + HILOG_INFO("failed to stop service ability."); + } + + return result; +} + +ErrCode SystemTestFormUtil::ConnectAbility(const Want &want, const sptr &connect, + const sptr &callerToken, unsigned int usec) +{ + ErrCode result = OHOS::ERR_OK; + + sptr abilityMs = GetAbilityManagerService(); + if (abilityMs == nullptr) { + result = OHOS::ERR_INVALID_VALUE; + HILOG_ERROR("failed to get ability manager service"); + return result; + } + + result = abilityMs->ConnectAbility(want, connect, callerToken); + if (result == OHOS::ERR_OK) { + HILOG_INFO("connect ability successfully."); + } else { + HILOG_INFO("failed to connect ability."); + } + + return result; +} + +ErrCode SystemTestFormUtil::DisconnectAbility(const sptr &connect, unsigned int usec) +{ + ErrCode result = OHOS::ERR_OK; + + sptr abilityMs = GetAbilityManagerService(); + if (abilityMs == nullptr) { + result = OHOS::ERR_INVALID_VALUE; + HILOG_ERROR("failed to get ability manager service"); + return result; + } + + result = abilityMs->DisconnectAbility(connect); + if (result == OHOS::ERR_OK) { + HILOG_INFO("StopServiceAbility successfully."); + } else { + HILOG_INFO("failed to StopServiceAbility."); + } + + return result; +} + +Want SystemTestFormUtil::MakeWant(std::string deviceId, std::string abilityName, std::string bundleName, MAP_STR_STR params) +{ + ElementName element(deviceId, bundleName, abilityName); + Want want; + want.SetElement(element); + for (const auto ¶m : params) { + want.SetParam(param.first, param.second); + } + return want; +} + +Want SystemTestFormUtil::MakeWant(std::string deviceId, std::string abilityName, std::string bundleName, vector_str params) +{ + ElementName element(deviceId, bundleName, abilityName); + Want want; + want.SetElement(element); + want.SetParam("operator", params); + return want; +} + +ErrCode SystemTestFormUtil::GetTopAbilityRecordId(int64_t &id, sptr &abilityMs) +{ + ErrCode result = OHOS::ERR_OK; + id = -1; + abilityMs = GetAbilityManagerService(); + if (abilityMs == nullptr) { + result = OHOS::ERR_INVALID_VALUE; + HILOG_ERROR("failed to get ability manager service"); + return result; + } + StackInfo stackInfo; + abilityMs->GetAllStackInfo(stackInfo); + MissionStackInfo defaultMissionStack; + for (const auto &stackInfo : stackInfo.missionStackInfos) { + if (stackInfo.id == 1) { // DEFAULT_MISSION_STACK_ID = 1 + defaultMissionStack = stackInfo; + break; + } + } + if (!defaultMissionStack.missionRecords.empty() && + !defaultMissionStack.missionRecords.begin()->abilityRecordInfos.empty()) { + id = defaultMissionStack.missionRecords.begin()->abilityRecordInfos.begin()->id; + } + return result; +} + +ErrCode SystemTestFormUtil::GetRunningProcessInfo( + std::vector &runningProcessInfo, sptr &appMs, const time_t &delay) +{ + ErrCode result = ERR_OK; + appMs = GetAppMgrService(); + if (appMs == nullptr) { + result = OHOS::ERR_INVALID_VALUE; + HILOG_ERROR("failed to get app manager service"); + return result; + } + std::this_thread::sleep_for(std::chrono::milliseconds(delay)); + result = appMs->GetAllRunningProcesses(runningProcessInfo); + if (result == ERR_OK) { + HILOG_INFO("get running process info successfully."); + } else { + HILOG_INFO("failed to get running process info."); + } + return result; +} + +ErrCode SystemTestFormUtil::KillApplication(const std::string &appName, sptr &appMs, const time_t &delay) +{ + ErrCode result = ERR_OK; + appMs = GetAppMgrService(); + if (appMs == nullptr) { + result = OHOS::ERR_INVALID_VALUE; + HILOG_ERROR("failed to get app manager service"); + return result; + } + result = appMs->GetAmsMgr()->KillApplication(appName); + std::this_thread::sleep_for(std::chrono::milliseconds(delay)); + if (result == ERR_OK) { + HILOG_INFO("kill application:%{public}s successfully.", appName.c_str()); + } else { + HILOG_INFO("failed to kill application:%{public}s.", appName.c_str()); + } + return result; +} + +RunningProcessInfo SystemTestFormUtil::GetAppProcessInfoByName( + const std::string &processName, sptr &appMs, const time_t &delay) +{ + RunningProcessInfo appProcessInfo; + appProcessInfo.pid_ = 0; + std::vector runningProcessInfo; + if (ERR_OK == GetRunningProcessInfo(runningProcessInfo, appMs, delay)) { + for (const auto &info : runningProcessInfo) { + if (processName == info.processName_) { + appProcessInfo = info; + } + } + } + return appProcessInfo; +} + +int SystemTestFormUtil::WaitCompleted(FormEvent &event, const std::string &eventName, const int code, const int timeout) +{ + HILOG_INFO("WaitCompleted"); + return event.WaitingMessage(std::to_string(code) + eventName, timeout, false); +} + +void SystemTestFormUtil::Completed(FormEvent &event, const std::string &eventName, const int code) +{ + HILOG_INFO("Completed"); + return event.CompleteMessage(std::to_string(code) + eventName); +} + +void SystemTestFormUtil::Completed(FormEvent &event, const std::string &eventName, const int code, const std::string &data) +{ + HILOG_INFO("SystemTestFormUtil::Completed"); + return event.CompleteMessage(std::to_string(code) + eventName, data); +} + +std::string SystemTestFormUtil::GetData(FormEvent &event, const std::string &eventName, const int code) +{ + HILOG_INFO("SystemTestFormUtil::GetData"); + return event.GetData(std::to_string(code) + eventName); +} + +void SystemTestFormUtil::CleanMsg(FormEvent &event) +{ + HILOG_INFO("CleanMsg"); + return event.Clean(); +} + +std::vector SystemTestFormUtil::SerializationStOperatorToVector(FormStOperator &ParentOperator) +{ + std::vector vectorOperator; + PushOperatorInVector(vectorOperator, ParentOperator); + return vectorOperator; +} + +void SystemTestFormUtil::DeserializationStOperatorFromVector( + FormStOperator &ParentOperator, std::vector &vectorOperator) +{ + PullOperatorFromVector(ParentOperator, vectorOperator); +} + +void SystemTestFormUtil::PushOperatorInVector(std::vector &vectorOperator, FormStOperator &ParentOperator) +{ + vectorOperator.emplace_back(std::to_string(ParentOperator.GetChildOperator().size())); + vectorOperator.emplace_back(ParentOperator.GetAbilityType()); + vectorOperator.emplace_back(ParentOperator.GetBundleName()); + vectorOperator.emplace_back(ParentOperator.GetAbilityName()); + vectorOperator.emplace_back(ParentOperator.GetOperatorName()); + vectorOperator.emplace_back(ParentOperator.GetMessage()); + for (auto child : ParentOperator.GetChildOperator()) { + PushOperatorInVector(vectorOperator, *child); + } +} + +void SystemTestFormUtil::PullOperatorFromVector(FormStOperator &ParentOperator, std::vector &vectorOperator) +{ + int childnum = std::stoi(vectorOperator.front()); + vectorOperator.erase(vectorOperator.begin()); + std::string abilityType = vectorOperator.front(); + vectorOperator.erase(vectorOperator.begin()); + std::string bundleName = vectorOperator.front(); + vectorOperator.erase(vectorOperator.begin()); + std::string abilityName = vectorOperator.front(); + vectorOperator.erase(vectorOperator.begin()); + std::string operatorName = vectorOperator.front(); + vectorOperator.erase(vectorOperator.begin()); + std::string message = vectorOperator.front(); + vectorOperator.erase(vectorOperator.begin()); + ParentOperator.SetAbilityType(abilityType) + .SetBundleName(bundleName) + .SetAbilityName(abilityName) + .SetOperatorName(operatorName) + .SetMessage(message); + for (int i = 0; i < childnum; i++) { + auto child = std::make_shared(); + if (child == nullptr) { + return; + } + ParentOperator.AddChildOperator(child); + PullOperatorFromVector(*(child.get()), vectorOperator); + } +} + +int SystemTestFormUtil::RemoveStack( + int id, sptr &abilityMs, const time_t &backHmoeDelay, const time_t &removeDelay) +{ + Want wantEntity; + wantEntity.AddEntity(Want::FLAG_HOME_INTENT_FROM_SYSTEM); + StartAbility(wantEntity, abilityMs); + std::this_thread::sleep_for(std::chrono::milliseconds(backHmoeDelay)); + if (!abilityMs) { + HILOG_INFO("RemoveStack abilityMs nullptr"); + return OHOS::ERR_INVALID_VALUE; + } + int result = abilityMs->RemoveStack(id); + std::this_thread::sleep_for(std::chrono::milliseconds(removeDelay)); + return result; +} + +class InstallToolStatusReceiver : public StatusReceiverHost { +public: + InstallToolStatusReceiver(); + virtual ~InstallToolStatusReceiver() override; + virtual void OnStatusNotify(const int progress) override; + virtual void OnFinished(const int32_t resultCode, const std::string &resultMsg) override; + static int TestWaitCompleted(FormEvent &event, const std::string eventName, const int code, const int timeout = 10); + static void TestCompleted(FormEvent &event, const std::string &eventName, const int code); + FormEvent event_ = STtools::FormEvent(); + +private: + int iProgress_ = 0; + DISALLOW_COPY_AND_MOVE(InstallToolStatusReceiver); +}; +InstallToolStatusReceiver::InstallToolStatusReceiver() +{ + std::cout << "create status receiver instance" << std::endl; +} + +InstallToolStatusReceiver::~InstallToolStatusReceiver() +{ + std::cout << "destroy status receiver instance" << std::endl; +} + +void InstallToolStatusReceiver::OnStatusNotify(const int progress) +{ + iProgress_ = progress; + std::cout << "destroy status receiver instance" << progress << std::endl; +} + +void InstallToolStatusReceiver::OnFinished(const int32_t resultCode, const std::string &resultMsg) +{ + std::cout << "on finished result is " << resultCode << " " << resultMsg << std::endl; + TestCompleted(event_, resultMsg, resultCode); +} + +int InstallToolStatusReceiver::TestWaitCompleted( + FormEvent &event, const std::string eventName, const int code, const int timeout) +{ + std::cout << "TestWaitCompleted " << eventName << std::endl; + return SystemTestFormUtil::WaitCompleted(event, eventName, code, timeout); +} +void InstallToolStatusReceiver::TestCompleted(FormEvent &event, const std::string &eventName, const int code) +{ + std::cout << "TestCompleted " << eventName << std::endl; + SystemTestFormUtil::Completed(event, eventName, code); + return; +} + +const std::string MSG_SUCCESS = "[SUCCESS]"; +void SystemTestFormUtil::Install(const std::string &bundleFilePath, const InstallFlag installFlag) +{ + std::string bundlePath = "/system/vendor/" + bundleFilePath + ".hap"; + std::string installMsg = ""; + sptr installerProxy = GetInstallerProxy(); + if (!installerProxy) { + std::cout << "get bundle installer Failure." << std::endl; + installMsg = "Failure"; + return; + } + + InstallParam installParam; + installParam.installFlag = installFlag; + sptr statusReceiver(new (std::nothrow) InstallToolStatusReceiver()); + if (statusReceiver == nullptr) { + std::cout << "get statusReceiver Failure." << std::endl; + return; + } + bool installResult = installerProxy->Install(bundlePath, installParam, statusReceiver); + if (!installResult) { + installMsg = "Failure"; + return; + } + if (InstallToolStatusReceiver::TestWaitCompleted(statusReceiver->event_, MSG_SUCCESS, 0) == 0) { + installMsg = "Success"; + } else { + installMsg = "Failure"; + } +} + +void SystemTestFormUtil::Uninstall(const std::string &bundleName) +{ + std::string uninstallMsg = ""; + sptr installerProxy = GetInstallerProxy(); + if (!installerProxy) { + std::cout << "get bundle installer Failure." << std::endl; + uninstallMsg = "Failure"; + return; + } + if (bundleName.empty()) { + std::cout << "bundelname is null." << std::endl; + uninstallMsg = "Failure"; + } else { + sptr statusReceiver(new (std::nothrow) InstallToolStatusReceiver()); + if (statusReceiver == nullptr) { + std::cout << "get statusReceiver Failure." << std::endl; + uninstallMsg = "Failure"; + return; + } + InstallParam installParam; + bool uninstallResult = installerProxy->Uninstall(bundleName, installParam, statusReceiver); + if (!uninstallResult) { + std::cout << "Uninstall Failure." << std::endl; + uninstallMsg = "Failure"; + return; + } + if (InstallToolStatusReceiver::TestWaitCompleted(statusReceiver->event_, MSG_SUCCESS, 0) == 0) { + uninstallMsg = "Success"; + } else { + uninstallMsg = "Failure"; + } + } +} + +sptr SystemTestFormUtil::GetInstallerProxy() +{ + sptr bundleMgrProxy = GetBundleMgrProxy(); + if (!bundleMgrProxy) { + std::cout << "bundle mgr proxy is nullptr." << std::endl; + return nullptr; + } + + sptr installerProxy = bundleMgrProxy->GetBundleInstaller(); + if (!installerProxy) { + std::cout << "fail to get bundle installer proxy" << std::endl; + return nullptr; + } + std::cout << "get bundle installer proxy success." << std::endl; + return installerProxy; +} + +sptr SystemTestFormUtil::GetBundleMgrProxy() +{ + sptr systemAbilityManager = + SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (!systemAbilityManager) { + std::cout << "fail to get system ability mgr." << std::endl; + return nullptr; + } + + sptr remoteObject = systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID); + if (!remoteObject) { + std::cout << "fail to get bundle manager proxy." << std::endl; + return nullptr; + } + + std::cout << "get bundle manager proxy success." << std::endl; + return iface_cast(remoteObject); +} + +/** + * @brief Query all of form storage infos. + * @return Returns all of form storage infos. + */ +std::string SystemTestFormUtil::QueryStorageFormInfos() +{ + std::cout << "QueryStorageFormInfos called." << std::endl; + + std::string formInfos = ""; + MessageParcel data; + if (!WriteInterfaceToken(data)) { + std::cout << "QueryStorageFormInfos, failed to write interface token." << std::endl; + return "QueryStorageFormInfos, failed to write interface token."; + } + + int result = GetStringInfo(AppExecFwk::IFormMgr::Message::FORM_MGR_STORAGE_FORM_INFOS, data, formInfos); + if (result != ERR_OK) { + std::cout << "QueryStorageFormInfos, failed to query form info." << std::endl; + } + + std::cout << "QueryStorageFormInfos end." << std::endl; + + return formInfos; +} +/** + * @brief Query form infos by bundleName. + * @param bundleName BundleName. + * @return Returns form infos. + */ +std::string SystemTestFormUtil::QueryFormInfoByBundleName(const std::string& bundleName) +{ + std::cout << "QueryFormInfoByBundleName called." << std::endl; + + std::string formInfos = ""; + MessageParcel data; + if (!WriteInterfaceToken(data)) { + std::cout << "QueryFormInfoByBundleName, failed to write interface token." << std::endl; + return "QueryFormInfoByBundleName, failed to write interface token."; + } + + if (!data.WriteString(bundleName)) { + std::cout << "QueryFormInfoByBundleName, failed to write bundleName." << std::endl; + return "QueryFormInfoByBundleName, failed to write bundleName."; + } + + int result = GetStringInfo(AppExecFwk::IFormMgr::Message::FORM_MGR_FORM_INFOS_BY_NAME, data, formInfos); + if (result != ERR_OK) { + std::cout << "QueryFormInfoByBundleName, failed to query form info." << std::endl; + } + + std::cout << "QueryFormInfoByBundleName end." << std::endl; + + return formInfos; +} +/** + * @brief Query form infos by form id. + * @param formId The id of the form. + * @return Returns form infos. + */ +std::string SystemTestFormUtil::QueryFormInfoByFormId(const std::int64_t formId) +{ + std::cout << "QueryFormInfoByFormId called." << std::endl; + + std::string formInfo = ""; + MessageParcel data; + if (!WriteInterfaceToken(data)) { + std::cout << "QueryFormInfoByFormId, failed to write interface token." << std::endl; + return "QueryFormInfoByFormId, failed to write interface token."; + } + if (!data.WriteInt64(formId)) { + std::cout << "QueryFormInfoByFormId, failed to write formId." << std::endl; + return "QueryFormInfoByFormId, failed to write formId."; + } + + int result = GetStringInfo(AppExecFwk::IFormMgr::Message::FORM_MGR_FORM_INFOS_BY_ID, data, formInfo); + if (result != ERR_OK) { + std::cout << "QueryFormInfoByFormId, failed to query form info." << std::endl; + } + + std::cout << "QueryFormInfoByFormId end." << std::endl; + + return formInfo; +} +bool SystemTestFormUtil::WriteInterfaceToken(MessageParcel &data) +{ + if (!data.WriteInterfaceToken(AppExecFwk::IFormMgr::GetDescriptor())) { + std::cout << "WriteInterfaceToken, failed to write interface token." << std::endl; + return false; + } + return true; +} +int SystemTestFormUtil::GetStringInfo(AppExecFwk::IFormMgr::Message code, MessageParcel &data, std::string &stringInfo) +{ + int error; + MessageParcel reply; + error = SendTransactCmd(code, data, reply); + if (error != ERR_OK) { + return error; + } + + error = reply.ReadInt32(); + if (error != ERR_OK) { + std::cout << "GetStringInfo, failed to read reply result." << std::endl; + return error; + } + std::vector stringInfoList; + if (!reply.ReadStringVector(&stringInfoList)) { + std::cout << "GetStringInfo, failed to read string vector from reply." << std::endl; + return ERR_APPEXECFWK_FORM_NOT_EXIST_ID; + } + if (stringInfoList.empty()) { + std::cout << "GetStringInfo, No string info." << std::endl; + return ERR_APPEXECFWK_FORM_NOT_EXIST_ID; + } + for (auto &info : stringInfoList) { + stringInfo += info; + } + std::cout << "GetStringInfo end." << std::endl; + return ERR_OK; +} +int SystemTestFormUtil::SendTransactCmd(AppExecFwk::IFormMgr::Message code, MessageParcel &data, MessageParcel &reply) +{ + sptr remoteObject = GetFmsService(); + if (!remoteObject) { + std::cout << "SendTransactCmd, failed to get remote object." << std::endl; + return ERR_APPEXECFWK_SERVICE_NOT_CONNECTED; + } + + MessageOption option(MessageOption::TF_SYNC); + int32_t result = remoteObject->SendRequest(static_cast(code), data, reply, option); + if (result != ERR_OK) { + std::cout << "SendTransactCmd, failed to SendRequest." << std::endl; + return result; + } + return ERR_OK; +} +/** + * @brief Get form manager service. + * @return Returns form manager servic remoteObject. + */ +sptr SystemTestFormUtil::GetFmsService() +{ + + sptr systemManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (systemManager == nullptr) { + std::cout << "SendTransactCmd, failed to get system ability manager." << std::endl; + return nullptr; + } + sptr remoteObject = systemManager->GetSystemAbility(FORM_MGR_SERVICE_ID); + + std::cout << "SendTransactCmd end." << std::endl; + return remoteObject; +} +} // namespace STtools +} // namespace OHOS \ No newline at end of file diff --git a/test/systemtest/common/fms/fms_acquire_form_test/BUILD.gn b/test/systemtest/common/fms/fms_acquire_form_test/BUILD.gn new file mode 100644 index 0000000000..02e917e811 --- /dev/null +++ b/test/systemtest/common/fms/fms_acquire_form_test/BUILD.gn @@ -0,0 +1,75 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/appexecfwk/standard/appexecfwk.gni") + +module_output_path = "appexecfwk_standard/formmanagerst" + +ohos_systemtest("FormAcquireFormTest") { + module_out_path = module_output_path + include_dirs = [ + "${aafwk_path}/interfaces/innerkits/ability_manager/include", + "${appexecfwk_path}/test/systemtest/common/fms/common/include", + "//base/notification/ces_standard/test/systemtest/common/resource", + "//foundation/distributedschedule/safwk/services/safwk/include", + ] + + sources = [ + "${appexecfwk_path}/test/systemtest/common/fms/common/src/form_event.cpp", + "${appexecfwk_path}/test/systemtest/common/fms/common/src/form_st_dump_util.cpp", + "${appexecfwk_path}/test/systemtest/common/fms/common/src/form_st_operator.cpp", + "${appexecfwk_path}/test/systemtest/common/fms/common/src/form_st_util.cpp", + "fms_acquire_form_test.cpp", + ] + + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + + configs = [ + "${aafwk_path}/services/abilitymgr:abilityms_config", + "${appexecfwk_path}/services/appmgr:appmgr_config", + ] + + deps = [ + "${aafwk_path}/frameworks/kits/ability/native:abilitykit_native", + "${aafwk_path}/services/abilitymgr:abilityms", + "${appexecfwk_path}/common:libappexecfwk_common", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//third_party/googletest:gtest_main", + ] + + defines = [ "APP_LOG_TAG = \"FMSAcquireFormTest\"" ] + + external_deps = [ + "aafwk_standard:base", + "aafwk_standard:want", + "appexecfwk_standard:appexecfwk_base", + "appexecfwk_standard:appexecfwk_core", + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr_L2:samgr_proxy", + ] +} + +group("systemtest") { + testonly = true + + deps = [ ":FormAcquireFormTest" ] +} diff --git a/test/systemtest/common/fms/fms_acquire_form_test/fms_acquire_form_test.cpp b/test/systemtest/common/fms/fms_acquire_form_test/fms_acquire_form_test.cpp new file mode 100644 index 0000000000..03472f4ed2 --- /dev/null +++ b/test/systemtest/common/fms/fms_acquire_form_test/fms_acquire_form_test.cpp @@ -0,0 +1,1305 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include "app_log_wrapper.h" +#include "ability_info.h" +#include "ability_handler.h" +#include "ability_local_record.h" +#include "ability_start_setting.h" +#include "common_event.h" +#include "common_event_manager.h" +#include "context_deal.h" +#include "form_event.h" +#include "form_st_common_info.h" +#include "form_st_util.h" +#include "iservice_registry.h" +#include "nlohmann/json.hpp" +#include "system_ability_definition.h" + +using OHOS::AAFwk::Want; +using namespace testing::ext; +using namespace std::chrono_literals; +using namespace OHOS::STtools; + +namespace { +std::vector bundleNameList = { + "com.ohos.form.manager.normal", + "com.ohos.form.manager.normalb", + // "com.ohos.form.manager.notsystemapp", + // "com.ohos.form.manager.nopermission", +}; +std::vector hapNameList = { + "fmsSystemTestHostNormal-signed", + "fmsSystemTestHostNormalB-signed", +}; + +std::string catchFormId; // FormId when creating a cached form +} // namespace + +namespace OHOS { +namespace AppExecFwk { +class FormAcquireFormTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + + static bool SubscribeEvent(); + + void SetUp(); + void TearDown(); + + void StartAbilityKitTest(const std::string &abilityName, const std::string &bundleName); + void TerminateAbility(const std::string &eventName, const std::string &abilityName); + + class FormEventSubscriber : public CommonEventSubscriber { + public: + explicit FormEventSubscriber(const CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp){}; + virtual void OnReceiveEvent(const CommonEventData &data) override; + ~FormEventSubscriber() = default; + }; + + static sptr abilityMs; + static FormEvent event; + // static FormEvent formEvent; + static std::vector eventList; + static std::shared_ptr subscriber_; + + void FmsAcquireForm1600(); + void FmsAcquireForm1600_1(); + void FmsAcquireForm1800(); + void FmsAcquireForm1800_1(); + void FmsAcquireForm1800_2(); + void FmsAcquireForm1800_3(); +}; + +std::vector FormAcquireFormTest::eventList = {FORM_EVENT_RECV_DELETE_FORM_COMMON, + FORM_EVENT_ABILITY_ONACTIVED, FORM_EVENT_RECV_ACQUIRE_FORM_0100, FORM_EVENT_RECV_ACQUIRE_FORM_0200, + FORM_EVENT_RECV_ACQUIRE_FORM_0300, FORM_EVENT_RECV_ACQUIRE_FORM_0400, FORM_EVENT_RECV_ACQUIRE_FORM_0500, + FORM_EVENT_RECV_ACQUIRE_FORM_0600, FORM_EVENT_RECV_ACQUIRE_FORM_0700, FORM_EVENT_RECV_ACQUIRE_FORM_1000, + FORM_EVENT_RECV_ACQUIRE_FORM_1100, FORM_EVENT_RECV_ACQUIRE_FORM_1200, FORM_EVENT_RECV_ACQUIRE_FORM_1400, + FORM_EVENT_RECV_ACQUIRE_FORM_1500, FORM_EVENT_RECV_ACQUIRE_FORM_1600, FORM_EVENT_RECV_ACQUIRE_FORM_1600_1, + FORM_EVENT_RECV_ACQUIRE_FORM_1800, FORM_EVENT_RECV_ACQUIRE_FORM_1800_1, FORM_EVENT_RECV_ACQUIRE_FORM_1800_2, + FORM_EVENT_RECV_ACQUIRE_FORM_1800_3, FORM_EVENT_RECV_ACQUIRE_FORM_1900, FORM_EVENT_RECV_ACQUIRE_FORM_2100, + FORM_EVENT_RECV_ACQUIRE_FORM_2200, FORM_EVENT_RECV_ACQUIRE_FORM_2300, FORM_EVENT_RECV_ACQUIRE_FORM_2500, + FORM_EVENT_RECV_ACQUIRE_FORM_1500_1, FORM_EVENT_RECV_ACQUIRE_FORM_2600, FORM_EVENT_RECV_ACQUIRE_FORM_2600_1, +}; + + +FormEvent FormAcquireFormTest::event = FormEvent(); +// FormEvent FormAcquireFormTest::formEvent = FormEvent(); +sptr FormAcquireFormTest::abilityMs = nullptr; +std::shared_ptr FormAcquireFormTest::subscriber_ = nullptr; +void FormAcquireFormTest::FormEventSubscriber::OnReceiveEvent(const CommonEventData &data) +{ + GTEST_LOG_(INFO) << "OnReceiveEvent: event=" << data.GetWant().GetAction(); + GTEST_LOG_(INFO) << "OnReceiveEvent: data=" << data.GetData(); + GTEST_LOG_(INFO) << "OnReceiveEvent: code=" << data.GetCode(); + SystemTestFormUtil::Completed(event, data.GetWant().GetAction(), data.GetCode(), data.GetData()); +} + +void FormAcquireFormTest::SetUpTestCase() +{ + SystemTestFormUtil::InstallHaps(hapNameList); + if (!SubscribeEvent()) { + GTEST_LOG_(INFO) << "SubscribeEvent error"; + } +} + +void FormAcquireFormTest::TearDownTestCase() +{ + GTEST_LOG_(INFO) << "UnSubscribeCommonEvent calld"; + SystemTestFormUtil::UninstallBundle(bundleNameList); + CommonEventManager::UnSubscribeCommonEvent(subscriber_); +} + +void FormAcquireFormTest::SetUp() +{ +} + +void FormAcquireFormTest::TearDown() +{ + GTEST_LOG_(INFO) << "CleanMsg calld"; + SystemTestFormUtil::CleanMsg(event); + // SystemTestFormUtil::CleanMsg(formEvent); +} +bool FormAcquireFormTest::SubscribeEvent() +{ + GTEST_LOG_(INFO) << "SubscribeEvent calld"; + MatchingSkills matchingSkills; + for (const auto &e : eventList) { + matchingSkills.AddEvent(e); + } + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + subscribeInfo.SetPriority(1); + subscriber_ = std::make_shared(subscribeInfo); + return CommonEventManager::SubscribeCommonEvent(subscriber_); +} + +/** + * @tc.number: FMS_acquireForm_0100 + * @tc.name: Form user is not a system application + * @tc.desc: + * Preset conditions: + * 1.Form user is not a system application + * 2.Set the following parameters: + * ·formId: 0 + * ·bundleName: "com.form.formsystemtestservicea" + * ·moduleName: "formmodule001" + * ·formName: "Form_Js001" + * ·abilityName: "com.form.formmodule001.FormAbility001" + * ·formDimension:1 + * ·tempFormFlag:false + * Expected results: Failed to add form.(Error reason: Form user is not a system application.) + */ +// HWTEST_F(FormAcquireFormTest, FMS_acquireForm_0100, Function | MediumTest | Level1) +// { +// std::cout << "START FMS_acquireForm_0100" << std::endl; + +// std::string bundleName = "com.ohos.form.manager.notsystemapp"; +// std::string abilityName = "FormAbilityNotSys"; +// MAP_STR_STR params; +// Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); +// SystemTestFormUtil::StartAbility(want, abilityMs); +// EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + +// std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_0100; +// SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_0100, 100, eventData); +// EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_0100, 100)); +// std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_0100, 100); +// bool result = data == "false"; +// EXPECT_TRUE(result); +// if (!result) { +// GTEST_LOG_(INFO) << "FMS_acquireForm_0100, result:" << result; +// } + +// std::cout << "END FMS_acquireForm_0100" << std::endl; +// } + +/** + * @tc.number: FMS_acquireForm_0200 + * @tc.name: The form user does not have permission to use the form + * @tc.desc: + * Preset conditions: + * 1.The form user does not have permission to use the form + * 2.Set the following parameters: + * ·formId: 0 + * ·bundleName: "com.form.formsystemtestservicea" + * ·moduleName: "formmodule001" + * ·formName: "Form_Js001" + * ·abilityName: "com.form.formmodule001.FormAbility001" + * ·formDimension:1 + * ·tempFormFlag:false + * Expected results: Failed to add form.(Error reason: The form user does not have permission to use the form.) + */ +// HWTEST_F(FormAcquireFormTest, FMS_acquireForm_0200, Function | MediumTest | Level1) +// { +// std::cout << "START FMS_acquireForm_0200" << std::endl; + +// std::string bundleName = "com.ohos.form.manager.nopermission"; +// std::string abilityName = "FormAbilityNoPerm"; +// MAP_STR_STR params; +// Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); +// SystemTestFormUtil::StartAbility(want, abilityMs); +// EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + +// std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_0200; +// SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_0200, 200, eventData); +// EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_0200, 200)); +// std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_0200, 200); +// bool result = data == "false"; +// EXPECT_TRUE(result); +// if (!result) { +// GTEST_LOG_(INFO) << "FMS_acquireForm_0200, result:" << result; +// } + +// std::cout << "END FMS_acquireForm_0200" << std::endl; +// } + +/** + * @tc.number: FMS_acquireForm_0300 + * @tc.name: Failed to add form when parameter formId is wrong. + * @tc.desc: + * Preset conditions: + * 1.The Form user has permission to use the form + * 2.The form provider has provided usable forms + * 3.Set the following parameters: + * ·formId: -1 + * ·bundleName: "com.form.formsystemtestservicea" + * ·moduleName: "formmodule001" + * ·formName: "Form_Js001" + * ·abilityName: "com.form.formmodule001.FormAbility001" + * ·formDimension:1 + * ·tempFormFlag:false + * Expected results: Failed to add form.(Error reason: formId is wrong.) + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_0300, Function | MediumTest | Level1) +{ + std::cout << "START FMS_acquireForm_0300" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_0300; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_0300, 300, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_0300, 300)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_0300, 300); + bool result = data == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_acquireForm_0300, result:" << result; + } + std::cout << "END FMS_acquireForm_0300" << std::endl; +} + +/** + * @tc.number: FMS_acquireForm_0400 + * @tc.name: Failed to add form when parameter bundlename is wrong. + * @tc.desc: + * Preset conditions: + * 1.The Form user has permission to use the form + * 2.The form provider has provided usable forms + * 3.Set the following parameters: + * ·formId: 0 + * ·bundleName: "com.form.bundlename99" + * ·moduleName: "formmodule001" + * ·formName: "Form_Js001" + * ·abilityName: "com.form.formmodule001.FormAbility001" + * ·formDimension:1 + * ·tempFormFlag:false + * Expected results: Failed to add form.(Error reason: bundleName is wrong.) + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_0400, Function | MediumTest | Level1) +{ + std::cout << "START FMS_acquireForm_0400" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_0400; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_0400, 400, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_0400, 400)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_0400, 400); + bool result = data == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_acquireForm_0400, result:" << result; + } + std::cout << "END FMS_acquireForm_0400" << std::endl; +} + +/** + * @tc.number: FMS_acquireForm_0500 + * @tc.name: Failed to add form when parameter moduleName is wrong. + * @tc.desc: + * Preset conditions: + * 1.The Form user has permission to use the form + * 2.The form provider has provided usable forms + * 3.Set the following parameters: + * ·formId: 0 + * ·bundleName: "com.form.formsystemtestservicea" + * ·moduleName: "moduleName99" + * ·formName: "Form_Js001" + * ·abilityName: "com.form.formmodule001.FormAbility001" + * ·formDimension:1 + * ·tempFormFlag:false + * Expected results: Failed to add form.(Error reason: moduleName is wrong.) + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_0500, Function | MediumTest | Level1) +{ + std::cout << "START FMS_acquireForm_0500" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_0500; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_0500, 500, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_0500, 500)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_0500, 500); + bool result = data == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_acquireForm_0500, result:" << result; + } + std::cout << "END FMS_acquireForm_0500" << std::endl; +} + +/** + * @tc.number: FMS_acquireForm_0600 + * @tc.name: Failed to add form when parameter formName is wrong. + * @tc.desc: + * Preset conditions: + * 1.The Form user has permission to use the form + * 2.The form provider has provided usable forms + * 3.Set the following parameters: + * ·formId: 0 + * ·bundleName: "com.form.formsystemtestservicea" + * ·moduleName: "formmodule001" + * ·formName: "formName999" + * ·abilityName: "com.form.formmodule001.FormAbility001" + * ·formDimension:1 + * ·tempFormFlag:false + * Expected results: Failed to add form.(Error reason: formName is wrong.) + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_0600, Function | MediumTest | Level1) +{ + std::cout << "START FMS_acquireForm_0600" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_0600; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_0600, 600, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_0600, 600)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_0600, 600); + bool result = data == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_acquireForm_0600, result:" << result; + } + std::cout << "END FMS_acquireForm_0600" << std::endl; +} + +/** + * @tc.number: FMS_acquireForm_0700 + * @tc.name: Failed to add form when parameter abilityName is wrong. + * @tc.desc: + * Preset conditions: + * 1.The Form user has permission to use the form + * 2.The form provider has provided usable forms + * 3.Set the following parameters: + * ·formId: 0 + * ·bundleName: "com.form.formsystemtestservicea" + * ·moduleName: "formmodule001" + * ·formName: "Form_Js001" + * ·abilityName: "abilityName9" + * ·formDimension:1 + * ·tempFormFlag:false + * Expected results: Failed to add form.(Error reason: abilityName is wrong.) + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_0700, Function | MediumTest | Level1) +{ + std::cout << "START FMS_acquireForm_0700" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_0700; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_0700, 700, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_0700, 700)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_0700, 700); + bool result = data == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_acquireForm_0700, result:" << result; + } + std::cout << "END FMS_acquireForm_0700" << std::endl; +} +/** + * @tc.number: FMS_acquireForm_1000 + * @tc.name: Failed to add form when parameter form dimension is wrong. + * @tc.desc: + * Preset conditions: + * 1.The Form user has permission to use the form + * 2.The form provider has provided usable forms + * 3.Set the following parameters: + * ·formId: 0 + * ·bundleName: "com.form.formsystemtestservicea" + * ·moduleName: "formmodule001" + * ·formName: "Form_Js001" + * ·abilityName: "com.form.formmodule001.FormAbility001" + * ·formDimension:0 + * ·tempFormFlag:false + * Expected results: Failed to add form.(Error reason: form dimension is wrong.) + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_1000, Function | MediumTest | Level1) +{ + std::cout << "START FMS_acquireForm_1000" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_1000; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_1000, 1000, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1000, 1000)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1000, 1000); + bool result = data == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1000, result:" << result; + } + std::cout << "END FMS_acquireForm_1000" << std::endl; +} +/** + * @tc.number: FMS_acquireForm_1100 + * @tc.name: When the formId is set to 0, a non cached form is added. + * @tc.desc: + * Preset conditions: + * 1.The Form user has permission to use the form + * 2.The form provider has provided usable forms, and the form view data does not exceed 1K + * 3.Set the following parameters: + * ·formId: 0 + * ·bundleName: "com.form.formsystemtestservicea" + * ·moduleName: "formmodule001" + * ·formName: "Form_Js001" + * ·abilityName: "com.form.formmodule001.FormAbility001" + * ·formDimension:1 + * ·tempFormFlag:false + * Expected results: 1.form configuration information query succeeded.2.provider pulled up successfully. + * 3.return no data form object.4.Store form view data in cache. + * 5.onCreateForm is triggered.6.onAcquire is triggered. + * 7.return form object with data.8.form added successfully. + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_1100, Function | MediumTest | Level1) +{ + std::cout << "START FMS_acquireForm_1100" << std::endl; + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_1100; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_1100, 1100, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1100, 1100)); + std::string strFormId = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1100, 1100); + bool result = !strFormId.empty(); + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1100, result:" << result; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1100, formId:" << strFormId; + } + + catchFormId = strFormId; + + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1100, 1101)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1100, 1101); + bool result2 = !data2.empty(); + EXPECT_TRUE(result2); + if (!result2) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1100, result:" << result2; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1100, formData:" << data2; + } + int64_t formId = std::stoll(strFormId); + std::string cachedData = SystemTestFormUtil::QueryFormInfoByFormId(formId); + GTEST_LOG_(INFO) << "FMS_acquireForm_1100, cachedData:" << cachedData; + + // wait delete form + // EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999)); + // std::string data3 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999); + // bool result3 = data3 == "true"; + // EXPECT_TRUE(result3); + // if (!result3) { + // GTEST_LOG_(INFO) << "FMS_acquireForm_1100, delete form, result:" << result3; + // } + + std::cout << "END FMS_acquireForm_1100" << std::endl; +} +/** + * @tc.number: FMS_acquireForm_1200 + * @tc.name: When the form ID is set to 0, a non cached form is added. + * @tc.desc: + * Preset conditions: + * 1.The Form user has permission to use the form + * 2.Form provider B has provided usable forms and the form view data exceeds 1K + * 3.Set the following parameters: + * ·formId: 0 + * ·bundleName: "com.form.formsystemtestserviceb" + * ·moduleName: "formmodule001" + * ·formName: "Form_Js001" + * ·abilityName: "com.form.formmodule001.FormAbility001" + * ·formDimension:1 + * ·tempFormFlag:false + * Expected results: 1.form configuration information query succeeded.2.provider pulled up successfully.3.return no data form object. + * 4.Form view data is not stored in the cache.5.onCreateForm is triggered.6.onAcquire is triggered. + * 7.return form object with data.8.form added successfully. + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_1200, Function | MediumTest | Level1) +{ + std::cout << "START FMS_acquireForm_1200" << std::endl; + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_1200; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_1200, 1200, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1200, 1200)); + std::string strFormId = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1200, 1200); + bool result = !strFormId.empty(); + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1200, result:" << result; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1200, formId:" << strFormId; + } + + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1200, 1201)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1200, 1201); + bool result2 = !data2.empty(); + EXPECT_TRUE(result2); + if (!result2) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1200, result:" << result2; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1200, formData:" << data2; + } + + int64_t formId = std::stoll(strFormId); + std::string cachedData = SystemTestFormUtil::QueryFormInfoByFormId(formId); + GTEST_LOG_(INFO) << "FMS_acquireForm_1200, cachedData:" << cachedData; + + // wait delete form + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999)); + std::string data3 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999); + bool result3 = data3 == "true"; + EXPECT_TRUE(result3); + if (!result3) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1200, delete form, result:" << result3; + } + + std::cout << "END FMS_acquireForm_1200" << std::endl; +} + +/** + * @tc.number: FMS_acquireForm_1400 + * @tc.name: FormId does not match other parameters when adding a cached form. + * @tc.desc: + * Preset conditions: + * 1.Form users A and B have permission to use the form + * 2.Form user A has added a non cached card + * (refer to the setting parameters for successfully adding a non cached form) + * 3.Form user B set the following parameters: + * ·formId: formId added by form user A + * ·formName: "formName999" + * ·Other parameters are consistent with those of the added form. + * Expected results: 1.Failed to add form.(Failure reason: formId and form name do not match) + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_1400, Function | MediumTest | Level1) +{ + std::cout << "START FMS_acquireForm_1400" << std::endl; + std::string bundleName = "com.ohos.form.manager.normalb"; + std::string abilityName = "FormAbilityB"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = catchFormId; + GTEST_LOG_(INFO) << "FMS_acquireForm_1400, formId:" << eventData; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_1400, 1400, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1400, 1400)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1400, 1400); + bool result = data == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1400, result:" << result; + } + + std::cout << "END FMS_acquireForm_1400" << std::endl; +} + +/** + * @tc.number: FMS_acquireForm_1500 + * @tc.name: Add a cached form. + * @tc.desc: + * Preset conditions: + * 1.Form users A and B have permission to use the form + * 2.Form user A has created a non cached form + * (refer to the setting parameters for successfully creating a non cached form) + * 3.Form users B set the following parameters: + * ·formId: formId added by form user A + * ·Other parameters are consistent with those of the added form. + * Expected results: 1.form configuration information query succeeded.2.provider pulled up successfully. + * 3.return form object with data.4.onCreateForm is triggered. + * 5.onAcquire is triggered.6.return form object with data. + * 7.form added successfully. + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_1500, Function | MediumTest | Level1) +{ + std::cout << "START FMS_acquireForm_1500" << std::endl; + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + GTEST_LOG_(INFO) << "FMS_acquireForm_1500, add no catch form start"; + std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_1500_1; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_1500_1, 1510, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1500_1, 1510)); + std::string strFormId = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1500_1, 1510); + bool result = !strFormId.empty(); + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1500, result:" << result; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1500, formId:" << strFormId; + } + + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1500_1, 1511)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1500_1, 1511); + bool result2 = !data2.empty(); + EXPECT_TRUE(result2); + if (!result2) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1500, result:" << result2; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1500, formData:" << data2; + } + GTEST_LOG_(INFO) << "FMS_acquireForm_1500, add no catch form end"; + + std::string bundleName1 = "com.ohos.form.manager.normalb"; + std::string abilityName1 = "FormAbilityB"; + MAP_STR_STR params1; + Want want1 = SystemTestFormUtil::MakeWant("device", abilityName1, bundleName1, params1); + SystemTestFormUtil::StartAbility(want1, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + GTEST_LOG_(INFO) << "FMS_acquireForm_1500, add catched form start"; + std::string eventData2 = strFormId; + GTEST_LOG_(INFO) << "FMS_acquireForm_1500, formId:" << eventData2; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_1500, 1500, eventData2); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1500, 1500)); + std::string strFormId2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1500, 1500); + bool result3 = !strFormId2.empty(); + EXPECT_TRUE(result3); + if (!result3) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1500, result:" << result3; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1500, formId:" << strFormId2; + } + + GTEST_LOG_(INFO) << "FMS_acquireForm_1500, add catched form end"; + // wait delete form + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999)); + std::string data5 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999); + bool result5 = data5 == "true"; + EXPECT_TRUE(result5); + if (!result5) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1500, delete form, result:" << result5; + } + + std::cout << "END FMS_acquireForm_1500" << std::endl; +} + +/** + * @tc.number: FMS_acquireForm_1600 + * @tc.name: A single form user (using a single thread) continuously creates 2 normal and 2 temporary forms. + * @tc.desc: + * Preset conditions: + * 1.The Form user has permission to use the form + * Expected results: return form added successfully. + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_1600, Function | MediumTest | Level1) +{ + int normalCount = 0; + int tempCount = 0; + for (int iCount = 0; iCount < 2; iCount++) { + sleep(1); + FmsAcquireForm1600(); + normalCount++; + std::cout << "END FMS_acquireForm_1600, normal form end, count:" << normalCount << std::endl; + sleep(1); + FmsAcquireForm1600_1(); + tempCount++; + std::cout << "END FMS_acquireForm_1600_1, temp form end, count:" << tempCount << std::endl; + } +} + +/** + * @tc.number: FMS_acquireForm_1800 + * @tc.name: Multiple form users create one normal form and one temporary form respectively. + * @tc.desc: + * Preset conditions: + * 1.The Form user has permission to use the form + + * Expected results: return form added successfully. + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_1800, Function | MediumTest | Level1) +{ + sleep(1); + FmsAcquireForm1800(); + sleep(1); + FmsAcquireForm1800_1(); + sleep(1); + FmsAcquireForm1800_2(); + sleep(1); + FmsAcquireForm1800_3(); +} + +/** + * @tc.number: FMS_acquireForm_1900 + * @tc.name: Add a temporary form when the formId is set to 0. + * @tc.desc: + * Preset conditions: + * 1.The Form user has permission to use the form + * 2.set the following parameters: + * ·formId: 0 + * ·bundleName: "com.form.formsystemtestservicea" + * ·moduleName: "formmodule001" + * ·formName: "Form_Js001" + * ·abilityName: "com.form.formmodule001.FormAbility001" + * ·formDimension:1 + * ·tempFormFlag:true + * Expected results: When the formId is set to 0, the create temporary form interface returns success. + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_1900, Function | MediumTest | Level1) +{ + std::cout << "START FMS_acquireForm_1900" << std::endl; + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_1900; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_1900, 1900, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1900, 1900)); + std::string strFormId = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1900, 1900); + bool result = !strFormId.empty(); + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1900, result:" << result; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1900, normal, formId:" << strFormId; + } + + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1900, 1901)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1900, 1901); + bool result2 = !data2.empty(); + EXPECT_TRUE(result2); + if (!result2) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1900, result:" << result2; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1900, normal, formData:" << data2; + } + + // wait delete form + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999)); + std::string data3 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999); + bool result3 = data3 == "true"; + EXPECT_TRUE(result3); + if (!result3) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1900, delete form, result:" << result3; + } + + std::cout << "END FMS_acquireForm_1900" << std::endl; +} + +/** + * @tc.number: FMS_acquireForm_2100 + * @tc.name: 创建临时卡片时，卡片ID指定为已创建常态卡片ID. + * @tc.desc: + * Preset conditions: + * 1.The Form user has permission to use the form + * 2.卡片使用方成功创建1张常态卡片 + * 3.创建临时卡片时设定参数如下: + * ·formId: 2中已创建的卡片ID + * ·bundleName: "com.form.formsystemtestservicea" + * ·moduleName: "formmodule001" + * ·formName: "Form_Js001" + * ·abilityName: "com.form.formmodule001.FormAbility001" + * ·formDimension:1 + * ·tempFormFlag:true + * Expected results: 创建临时卡片接口返回失败.(Error reason: 不能指定卡片ID创建临时卡片.) + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_2100, Function | MediumTest | Level1) +{ + std::cout << "START FMS_acquireForm_2100" << std::endl; + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = catchFormId; + GTEST_LOG_(INFO) << "FMS_acquireForm_2100, formId:" << eventData; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_2100, 2100, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_2100, 2100)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_2100, 2100); + bool result = data == "false"; + EXPECT_TRUE(result); + GTEST_LOG_(INFO) << "FMS_acquireForm_2100, result:" << result; + std::cout << "END FMS_acquireForm_2100" << std::endl; +} + +/** + * @tc.number: FMS_acquireForm_2200 + * @tc.name: 临时卡片Id设为负数时转常态卡片. + * @tc.desc: + * Preset conditions: + * 1.The Form user has permission to use the form + * 2.卡片使用方成功创建1张常态卡片 + * 3.卡片使用方进行临时卡片转常态卡片时设定参数如下: + * ·formId: -1 + * Expected results: 创建临时卡片接口返回失败.(Error reason: 不能指定卡片ID创建临时卡片.) + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_2200, Function | MediumTest | Level1) +{ + std::cout << "START FMS_acquireForm_2200" << std::endl; + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_2200; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_2200, 2200, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_2200, 2200)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_2200, 2200); + bool result = data == "false"; + EXPECT_TRUE(result); + GTEST_LOG_(INFO) << "FMS_acquireForm_2200, result:" << result; + + std::cout << "END FMS_acquireForm_2200" << std::endl; +} + +/** + * @tc.number: FMS_acquireForm_2300 + * @tc.name: 临时卡片Id设为负数时转常态卡片. + * @tc.desc: + * Preset conditions: + * 1.The Form user has permission to use the form + * 2.卡片使用方成功创建1张常态卡片 + * 3.卡片使用方进行临时卡片转常态卡片时设定参数如下: + * ·formId: 0 + * Expected results: 创建临时卡片接口返回失败.(Error reason: 不能指定卡片ID创建临时卡片.) + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_2300, Function | MediumTest | Level1) +{ + std::cout << "START FMS_acquireForm_2300" << std::endl; + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_2300; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_2300, 2300, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_2300, 2300)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_2300, 2300); + bool result = data == "false"; + EXPECT_TRUE(result); + GTEST_LOG_(INFO) << "FMS_acquireForm_2300, result:" << result; + + std::cout << "END FMS_acquireForm_2300" << std::endl; +} + +/** + * @tc.number: FMS_acquireForm_2500 + * @tc.name: 用不存在的临时卡片ID转常态卡片. + * @tc.desc: + * Preset conditions: + * 1.The Form user has permission to use the form + * 2.卡片使用方成功创建1张常态卡片 + * 3.卡片使用方进行临时卡片转常态卡片时设定参数如下: + * ·formId: 不存在的ID + * Expected results: 创建临时卡片接口返回失败.(Error reason: 不能指定卡片ID创建临时卡片.) + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_2500, Function | MediumTest | Level1) +{ + std::cout << "START FMS_acquireForm_2500" << std::endl; + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_2500; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_2500, 2500, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_2500, 2500)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_2500, 2500); + bool result = data == "false"; + EXPECT_TRUE(result); + GTEST_LOG_(INFO) << "FMS_acquireForm_2500, result:" << result; + + std::cout << "END FMS_acquireForm_2500" << std::endl; +} + +/** + * @tc.number: FMS_acquireForm_2600 + * @tc.name: 当常态卡片没有达到卡片创建的最大值(单使用方为256，FMS为512)时，临时卡片转常态卡片. + * @tc.desc: + * Preset conditions: + * 1.The Form user has permission to use the form + * 2.卡片使用方已创建1张临时卡片 + * 3.卡片使用方进行临时卡片转常态卡片时设定参数如下: + * ·formId: 已创建临时卡片的卡片ID + * Expected results: 临时卡片转常态卡片接口返回成功. + */ +HWTEST_F(FormAcquireFormTest, FMS_acquireForm_2600, Function | MediumTest | Level1) +{ + std::cout << "START FMS_acquireForm_2600" << std::endl; + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_2600_1; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_2600_1, 2610, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_2600_1, 2610)); + std::string strFormId = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_2600_1, 2610); + bool result = !strFormId.empty(); + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_acquireForm_2600, result:" << result; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_2600, formId:" << strFormId; + } + + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_2600_1, 2611)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_2600_1, 2611); + bool result2 = !data2.empty(); + EXPECT_TRUE(result2); + if (!result2) { + GTEST_LOG_(INFO) << "FMS_acquireForm_2600, result:" << result2; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_2600, formData:" << data2; + } + + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + std::string eventData1 = strFormId; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_2600, 2600, eventData1); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_2600, 2600)); + std::string data3 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_2600, 2600); + bool result3 = data3 == "true"; + EXPECT_TRUE(result3); + GTEST_LOG_(INFO) << "FMS_acquireForm_2600, result:" << result3; + + // wait delete form + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999)); + std::string data4 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999); + bool result4 = data4 == "true"; + EXPECT_TRUE(result4); + if (!result4) { + GTEST_LOG_(INFO) << "FMS_acquireForm_2600, delete form, result:" << result4; + } + + std::cout << "END FMS_acquireForm_2600" << std::endl; +} + +void FormAcquireFormTest::FmsAcquireForm1600() +{ + std::cout << "START FMS_acquireForm_1600, normal form start." << std::endl; + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_1600; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_1600, 1600, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1600, 1600)); + std::string strFormId = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1600, 1600); + bool result = !strFormId.empty(); + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1600, result:" << result; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1600, formId:" << strFormId; + } + + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1600, 1601)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1600, 1601); + bool result2 = !data2.empty(); + EXPECT_TRUE(result2); + if (!result2) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1600, result:" << result2; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1600, formData:" << data2; + } + + // wait delete form + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999)); + std::string data3 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999); + bool result3 = data3 == "true"; + EXPECT_TRUE(result3); + if (!result3) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1600, delete form, result:" << result3; + } +} + +void FormAcquireFormTest::FmsAcquireForm1600_1() +{ + std::cout << "START FMS_acquireForm_1600_1, temp form start." << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData1 = FORM_EVENT_REQ_ACQUIRE_FORM_1600_1; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_1600_1, 1610, eventData1); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1600_1, 1610)); + std::string strFormId1 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1600_1, 1610); + bool result4 = !strFormId1.empty(); + EXPECT_TRUE(result4); + if (!result4) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1600_1, result:" << result4; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1600_1 formId:" << strFormId1; + } + + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1600_1, 1611)); + std::string data4 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1600_1, 1611); + bool result5 = !data4.empty(); + EXPECT_TRUE(result5); + if (!result5) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1600_1, result:" << result5; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1600_1, formData:" << data4; + } + + // wait delete form + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999)); + std::string data5 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999); + bool result6 = data5 == "true"; + EXPECT_TRUE(result6); + if (!result6) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1600_1, delete form, result:" << result6; + } +} +void FormAcquireFormTest::FmsAcquireForm1800() +{ + int normalCount = 0; + std::cout << "START FMS_acquireForm_1800, normal form start." << std::endl; + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + std::cout << "START FMS_acquireForm_1800, bundleName: "<< bundleName; + std::cout << "START FMS_acquireForm_1800, abilityName: "<< abilityName; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_1800; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_1800, 1800, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1800, 1800)); + std::string strFormId = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1800, 1800); + bool result = !strFormId.empty(); + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800, result:" << result; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800, formId:" << strFormId; + } + + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1800, 1801)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1800, 1801); + bool result2 = !data2.empty(); + EXPECT_TRUE(result2); + if (!result2) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800, result:" << result2; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800, formData:" << data2; + } + + // wait delete form + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999)); + std::string data3 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999); + bool result3 = data3 == "true"; + EXPECT_TRUE(result3); + if (!result3) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800, delete form, result:" << result3; + } + normalCount++; + std::cout << "END FMS_acquireForm_1800, normal form end, count:" << normalCount << std::endl; +} +void FormAcquireFormTest::FmsAcquireForm1800_1() +{ + int tempCount = 0; + std::cout << "START FMS_acquireForm_1800_1, temp form start." << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityA"; + std::cout << "START FMS_acquireForm_1800_1, bundleName: "<< bundleName; + std::cout << "START FMS_acquireForm_1800_1, abilityName: "<< abilityName; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData1 = FORM_EVENT_REQ_ACQUIRE_FORM_1800_1; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_1800_1, 1810, eventData1); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1800_1, 1810)); + std::string strFormId1 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1800_1, 1810); + bool result4 = !strFormId1.empty(); + EXPECT_TRUE(result4); + if (!result4) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800_1, result:" << result4; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800_1 formId:" << strFormId1; + } + + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1800_1, 1811)); + std::string data4 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1800_1, 1811); + bool result5 = !data4.empty(); + EXPECT_TRUE(result5); + if (!result5) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800_1, result:" << result5; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800_1, formData:" << data4; + } + + // wait delete form + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999)); + std::string data5 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999); + bool result6 = data5 == "true"; + EXPECT_TRUE(result6); + if (!result6) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800_1, delete form, result:" << result6; + } + tempCount++; + std::cout << "END FMS_acquireForm_1800_1, temp form end, count:" << tempCount << std::endl; +} +void FormAcquireFormTest::FmsAcquireForm1800_2() +{ + int normalCount = 0; + std::cout << "START FMS_acquireForm_1800_2, normal form start." << std::endl; + std::string bundleName = "com.ohos.form.manager.normalb"; + std::string abilityName = "FormAbilityB"; + std::cout << "START FMS_acquireForm_1800_2, bundleName: "<< bundleName; + std::cout << "START FMS_acquireForm_1800_2, abilityName: "<< abilityName; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_ACQUIRE_FORM_1800_2; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_1800_2, 1820, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1800_2, 1820)); + std::string strFormId = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1800_2, 1820); + bool result = !strFormId.empty(); + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800_2, result:" << result; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800_2, formId:" << strFormId; + } + + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1800_2, 1821)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1800_2, 1821); + bool result2 = !data2.empty(); + EXPECT_TRUE(result2); + if (!result2) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800_2, result:" << result2; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800_2, formData:" << data2; + } + + // wait delete form + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999)); + std::string data3 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999); + bool result3 = data3 == "true"; + EXPECT_TRUE(result3); + if (!result3) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800_2, delete form, result:" << result3; + } + normalCount++; + std::cout << "END FMS_acquireForm_1800_2, normal form end, count:" << normalCount << std::endl; +} +void FormAcquireFormTest::FmsAcquireForm1800_3() +{ + int tempCount = 0; + std::cout << "START FMS_acquireForm_1800_3, temp form start." << std::endl; + + std::string bundleName = "com.ohos.form.manager.normalb"; + std::string abilityName = "FormAbilityB"; + std::cout << "START FMS_acquireForm_1800_3, bundleName: "<< bundleName; + std::cout << "START FMS_acquireForm_1800_3, abilityName: "<< abilityName; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData1 = FORM_EVENT_REQ_ACQUIRE_FORM_1800_3; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ACQUIRE_FORM_1800_3, 1830, eventData1); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1800_3, 1830)); + std::string strFormId1 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1800_3, 1830); + bool result4 = !strFormId1.empty(); + EXPECT_TRUE(result4); + if (!result4) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800_3, result:" << result4; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800_3 formId:" << strFormId1; + } + + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ACQUIRE_FORM_1800_3, 1831)); + std::string data4 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ACQUIRE_FORM_1800_3, 1831); + bool result5 = !data4.empty(); + EXPECT_TRUE(result5); + if (!result5) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800_3, result:" << result5; + } else { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800_3, formData:" << data4; + } + + // wait delete form + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999)); + std::string data5 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_COMMON, 999); + bool result6 = data5 == "true"; + EXPECT_TRUE(result6); + if (!result6) { + GTEST_LOG_(INFO) << "FMS_acquireForm_1800_3, delete form, result:" << result6; + } + tempCount++; + std::cout << "END FMS_acquireForm_1800_3, temp form end, count:" << tempCount << std::endl; +} +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/systemtest/common/fms/fms_delete_form_test/BUILD.gn b/test/systemtest/common/fms/fms_delete_form_test/BUILD.gn new file mode 100644 index 0000000000..d4259e3aff --- /dev/null +++ b/test/systemtest/common/fms/fms_delete_form_test/BUILD.gn @@ -0,0 +1,75 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/appexecfwk/standard/appexecfwk.gni") + +module_output_path = "appexecfwk_standard/formmanagerst" + +ohos_systemtest("FormDeleteFormTest") { + module_out_path = module_output_path + include_dirs = [ + "${aafwk_path}/interfaces/innerkits/ability_manager/include", + "${appexecfwk_path}/test/systemtest/common/fms/common/include", + "//base/notification/ces_standard/test/systemtest/common/resource", + "//foundation/distributedschedule/safwk/services/safwk/include", + ] + + sources = [ + "${appexecfwk_path}/test/systemtest/common/fms/common/src/form_event.cpp", + "${appexecfwk_path}/test/systemtest/common/fms/common/src/form_st_dump_util.cpp", + "${appexecfwk_path}/test/systemtest/common/fms/common/src/form_st_operator.cpp", + "${appexecfwk_path}/test/systemtest/common/fms/common/src/form_st_util.cpp", + "fms_delete_form_test.cpp", + ] + + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + + configs = [ + "${aafwk_path}/services/abilitymgr:abilityms_config", + "${appexecfwk_path}/services/appmgr:appmgr_config", + ] + + deps = [ + "${aafwk_path}/frameworks/kits/ability/native:abilitykit_native", + "${aafwk_path}/services/abilitymgr:abilityms", + "${appexecfwk_path}/common:libappexecfwk_common", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//third_party/googletest:gtest_main", + ] + + defines = [ "APP_LOG_TAG = \"FMSDeleteFormTest\"" ] + + external_deps = [ + "aafwk_standard:base", + "aafwk_standard:want", + "appexecfwk_standard:appexecfwk_base", + "appexecfwk_standard:appexecfwk_core", + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr_L2:samgr_proxy", + ] +} + +group("systemtest") { + testonly = true + + deps = [ ":FormDeleteFormTest" ] +} diff --git a/test/systemtest/common/fms/fms_delete_form_test/fms_delete_form_test.cpp b/test/systemtest/common/fms/fms_delete_form_test/fms_delete_form_test.cpp new file mode 100644 index 0000000000..877312e036 --- /dev/null +++ b/test/systemtest/common/fms/fms_delete_form_test/fms_delete_form_test.cpp @@ -0,0 +1,803 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include "app_log_wrapper.h" +#include "ability_info.h" +#include "ability_handler.h" +#include "ability_local_record.h" +#include "ability_start_setting.h" +#include "common_event.h" +#include "common_event_manager.h" +#include "context_deal.h" +#include "form_event.h" +#include "form_st_common_info.h" +#include "form_st_util.h" +#include "iservice_registry.h" +#include "nlohmann/json.hpp" +#include "system_ability_definition.h" + +using OHOS::AAFwk::Want; +using namespace testing::ext; +using namespace std::chrono_literals; +using namespace OHOS::STtools; + +namespace { +std::vector bundleNameList = { + "com.ohos.form.manager.notsystemapp", + "com.ohos.form.manager.nopermission", + "com.ohos.form.manager.normal", + "com.ohos.form.manager.commona" +}; +std::vector hapNameList = { + "fmsSystemTestHostNotSys-signed", + "fmsSystemTestHostNoPerm-signed", + "fmsSystemTestHostNormal-signed", + "fmsSystemTestHostCommonA-signed" +}; +} // namespace + +namespace OHOS { +namespace AppExecFwk { +class FormDeleteFormTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + + static bool SubscribeEvent(); + + void SetUp(); + void TearDown(); + + void StartAbilityKitTest(const std::string &abilityName, const std::string &bundleName); + void TerminateAbility(const std::string &eventName, const std::string &abilityName); + + class FormEventSubscriber : public CommonEventSubscriber { + public: + explicit FormEventSubscriber(const CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp){}; + virtual void OnReceiveEvent(const CommonEventData &data) override; + ~FormEventSubscriber() = default; + }; + + static sptr abilityMs; + static FormEvent event; + // static FormEvent formEvent; + static std::vector eventList; + static std::shared_ptr subscriber_; +}; + +std::vector FormDeleteFormTest::eventList = { + FORM_EVENT_ABILITY_ONACTIVED, + FORM_EVENT_RECV_DELETE_FORM_0100, + FORM_EVENT_RECV_DELETE_FORM_0200, + FORM_EVENT_RECV_DELETE_FORM_0300, + FORM_EVENT_RECV_DELETE_FORM_0400, + FORM_EVENT_RECV_DELETE_FORM_0500, + FORM_EVENT_RECV_DELETE_FORM_0600, + FORM_EVENT_RECV_DELETE_FORM_0700, + FORM_EVENT_RECV_DELETE_FORM_0800, + FORM_EVENT_RECV_DELETE_FORM_0900, + FORM_EVENT_RECV_DELETE_FORM_1000, + FORM_EVENT_RECV_DELETE_FORM_1100, + FORM_EVENT_RECV_DELETE_FORM_1200, + FORM_EVENT_RECV_DELETE_FORM_1400, + FORM_EVENT_RECV_DELETE_FORM_1500, + FORM_EVENT_RECV_DELETE_FORM_1600, + FORM_EVENT_RECV_DELETE_FORM_1700, + FORM_EVENT_RECV_ONE_NORMAL_FORM, +}; + +static std::string form_id = ""; +FormEvent FormDeleteFormTest::event = FormEvent(); +// FormEvent FormDeleteFormTest::formEvent = FormEvent(); +sptr FormDeleteFormTest::abilityMs = nullptr; +std::shared_ptr FormDeleteFormTest::subscriber_ = nullptr; +void FormDeleteFormTest::FormEventSubscriber::OnReceiveEvent(const CommonEventData &data) +{ + GTEST_LOG_(INFO) << "OnReceiveEvent: event=" << data.GetWant().GetAction(); + GTEST_LOG_(INFO) << "OnReceiveEvent: data=" << data.GetData(); + GTEST_LOG_(INFO) << "OnReceiveEvent: code=" << data.GetCode(); + if (data.GetCode() == 110) { + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ONE_NORMAL_FORM, 110, data.GetData()); + } + SystemTestFormUtil::Completed(event, data.GetWant().GetAction(), data.GetCode(), data.GetData()); +} + +void FormDeleteFormTest::SetUpTestCase() +{ + std::cout << "START Install============" << std::endl; + SystemTestFormUtil::InstallHaps(hapNameList); + if (!SubscribeEvent()) { + GTEST_LOG_(INFO) << "SubscribeEvent error"; + } +} + +void FormDeleteFormTest::TearDownTestCase() +{ + std::cout << "START Uninstall============" << std::endl; + SystemTestFormUtil::UninstallBundle(bundleNameList); + CommonEventManager::UnSubscribeCommonEvent(subscriber_); +} + +void FormDeleteFormTest::SetUp() +{ +} + +void FormDeleteFormTest::TearDown() +{ + SystemTestFormUtil::CleanMsg(event); + // SystemTestFormUtil::CleanMsg(formEvent); +} +bool FormDeleteFormTest::SubscribeEvent() +{ + std::vector eventList = { + FORM_EVENT_ABILITY_ONACTIVED, + FORM_EVENT_RECV_DELETE_FORM_0100, + FORM_EVENT_RECV_DELETE_FORM_0200, + FORM_EVENT_RECV_DELETE_FORM_0300, + FORM_EVENT_RECV_DELETE_FORM_0400, + FORM_EVENT_RECV_DELETE_FORM_0500, + FORM_EVENT_RECV_DELETE_FORM_0600, + FORM_EVENT_RECV_DELETE_FORM_0700, + FORM_EVENT_RECV_DELETE_FORM_0800, + FORM_EVENT_RECV_DELETE_FORM_0900, + FORM_EVENT_RECV_DELETE_FORM_1000, + FORM_EVENT_RECV_DELETE_FORM_1100, + FORM_EVENT_RECV_DELETE_FORM_1200, + FORM_EVENT_RECV_DELETE_FORM_1400, + FORM_EVENT_RECV_DELETE_FORM_1500, + FORM_EVENT_RECV_DELETE_FORM_1600, + FORM_EVENT_RECV_DELETE_FORM_1700, + FORM_EVENT_RECV_ONE_NORMAL_FORM, + }; + MatchingSkills matchingSkills; + for (const auto &e : eventList) { + matchingSkills.AddEvent(e); + } + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + subscribeInfo.SetPriority(1); + subscriber_ = std::make_shared(subscribeInfo); + return CommonEventManager::SubscribeCommonEvent(subscriber_); +} + +/** + * @tc.number: FMS_deleteForm_0100 + * @tc.name: 卡片使用方不是系统应用 + * @tc.desc: + * 预置条件: + * 1.卡片使用方不是系统应用 + * 2.设置下面删除卡片参数： + * ·formId：1 + * 测试步骤: + * 1.调用删除卡片接口。 + * 2.验证删除卡片接口返回结果。 + * 预期结果: 删除卡片接口返回失败。（错误原因：卡片使用方不是系统应用。） + */ +HWTEST_F(FormDeleteFormTest, FMS_deleteForm_0100, Function | MediumTest | Level0) +{ + std::cout << "============START FMS_deleteForm_0100" << std::endl; + + std::string bundleName = "com.ohos.form.manager.notsystemapp"; + std::string abilityName = "FormAbilityNotSys"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_DELETE_FORM_0100; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_DELETE_FORM_0100, 100, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_0100, 100)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_0100, 100); + bool result = data == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_deleteForm_0100, result:" << result; + } + + std::cout << "============END FMS_deleteForm_0100" << std::endl; +} + +/** + * @tc.number: FMS_deleteForm_0200 + * @tc.name: 卡片使用方没有卡片使用权限 + * @tc.desc: + * 预置条件: + * 1.卡片使用方没有卡片使用权限 + * 2.设置下面删除卡片参数： + * ·formId：1 + * 测试步骤: + * 1.调用删除卡片接口。 + * 2.验证删除卡片接口返回结果。 + * 预期结果: 删除卡片接口返回失败。（错误原因：卡片使用方没有卡片权限。） + */ +HWTEST_F(FormDeleteFormTest, FMS_deleteForm_0200, Function | MediumTest | Level0) +{ + std::cout << "============START FMS_deleteForm_0200" << std::endl; + + std::string bundleName = "com.ohos.form.manager.nopermission"; + std::string abilityName = "FormAbilityNoPerm"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_DELETE_FORM_0200; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_DELETE_FORM_0200, 200, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_0200, 200)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_0200, 200); + bool result = data == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_deleteForm_0200, result:" << result; + } + + std::cout << "============END FMS_deleteForm_0200" << std::endl; +} + +/** + * @tc.number: FMS_deleteForm_0300 + * @tc.name: 卡片ID错误（formId < 0） + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.存在使用方已经创建的卡片 + * 2.设置下面删除卡片参数： + * ·formId：-1 + * 测试步骤: + * 1.调用删除卡片接口。 + * 2.验证删除卡片接口返回结果。 + * 预期结果: 删除卡片接口返回失败。（错误原因：卡片ID错误） + */ +HWTEST_F(FormDeleteFormTest, FMS_deleteForm_0300, Function | MediumTest | Level0) +{ + std::cout << "============START FMS_deleteForm_0300" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityDeleteForm"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_DELETE_FORM_0300; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_DELETE_FORM_0300, 300, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_0300, 300)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_0300, 300); + bool result = data == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_deleteForm_0300, result:" << result; + } + SystemTestFormUtil::CleanMsg(event); + std::cout << "============END FMS_deleteForm_0300" << std::endl; +} + +/** + * @tc.number: FMS_deleteForm_0400 + * @tc.name: 卡片ID错误（formId = 0） + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.存在使用方已经创建的卡片 + * 2.设置下面删除卡片参数： + * ·formId：0 + * 测试步骤: + * 1.调用删除卡片接口。 + * 2.验证删除卡片接口返回结果。 + * 预期结果: 删除卡片接口返回失败。（错误原因：卡片ID错误） + */ +HWTEST_F(FormDeleteFormTest, FMS_deleteForm_0400, Function | MediumTest | Level0) +{ + std::cout << "============START FMS_deleteForm_0400" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityDeleteForm"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_DELETE_FORM_0400; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_DELETE_FORM_0400, 400, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_0400, 400)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_0400, 400); + bool result = data == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_deleteForm_0400, result:" << result; + } + SystemTestFormUtil::CleanMsg(event); + std::cout << "============END FMS_deleteForm_0400" << std::endl; +} + +/** + * @tc.number: FMS_deleteForm_0500 + * @tc.name: 卡片ID错误（formId非所属） + * @tc.desc: + * 预置条件: + * 1.卡片使用方A，B有卡片使用权限 + * 2.卡片使用方A创建1张常态卡片 + * 3.设置下面删除卡片参数： + * ·formId：2创建卡片ID + * 测试步骤: + * 1.卡片使用方B调用删除卡片接口。 + * 2.验证删除卡片接口返回结果。 + * 预期结果: 删除卡片接口返回失败。（错误原因：卡片ID错误） + */ +HWTEST_F(FormDeleteFormTest, FMS_deleteForm_0500, Function | MediumTest | Level1) +{ + std::cout << "============START FMS_deleteForm_0500" << std::endl; + + std::string bundleName = "com.ohos.form.manager.commona"; + std::string abilityName = "FormAbilityCommonA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = "false"; //normal form + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ONE_NORMAL_FORM, 100, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100); + + GTEST_LOG_(INFO) << "FMS_deleteForm_0500, data:[" << data << "]" << std::endl; + bool result1 = data != ""; + EXPECT_TRUE(result1); + + if (data != "") { + std::string bundleName2 = "com.ohos.form.manager.normal"; + std::string abilityName2 = "FormAbilityDeleteForm"; + MAP_STR_STR params2; + Want want2 = SystemTestFormUtil::MakeWant("device", abilityName2, bundleName2, params2); + SystemTestFormUtil::StartAbility(want2, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData2 = data; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_DELETE_FORM_0500, 500, eventData2); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_0500, 500)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_0500, 500); + bool result2 = data2 == "false"; + EXPECT_TRUE(result2); + if (!result2) { + GTEST_LOG_(INFO) << "FMS_deleteForm_0500, result2:" << result2; + } + } + SystemTestFormUtil::CleanMsg(event); + + std::cout << "============END FMS_deleteForm_0500" << std::endl; +} + +/** + * @tc.number: FMS_deleteForm_0600 + * @tc.name: 删除常态卡片且删除后卡片引用不为0 + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.卡片使用方A创建常态卡片 + * 3.卡片使用方B用A的卡片ID创建常态卡片。 + * 4.设置下面删除卡片参数： + * ·formId：已创建的卡片ID + * 测试步骤: + * 1.卡片使用方A调用删除卡片接口。 + * 2.·验证卡片宿主对象是否被删除。 + * 3.验证卡片缓存数据是否被删除。 + * 4.验证卡片持久化数据是否被删除。 + * 5.验证卡片提供方是否收到卡片删除通知。 + * 6.验证删除卡片接口返回结果。 + * 预期结果: + * 1.卡片宿主对象被删除。 + * 2.卡片缓存数据不被删除。 + * 3.卡片持久化数据不被删除。 + * 4.卡片提供方不能收到卡片删除通知。 + * 5.删除卡片接口返回成功。 + */ +HWTEST_F(FormDeleteFormTest, FMS_deleteForm_0600, Function | MediumTest | Level1) +{ + std::cout << "============START FMS_deleteForm_0600" << std::endl; + + std::string bundleName = "com.ohos.form.manager.commona"; + std::string abilityName = "FormAbilityCommonA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = "false"; //normal form + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ONE_NORMAL_FORM, 100, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100); + + GTEST_LOG_(INFO) << "FMS_deleteForm_0600, data:[" << data << "]" << std::endl; + if (data != "") { + std::string bundleName2 = "com.ohos.form.manager.normal"; + std::string abilityName2 = "FormAbilityDeleteForm"; + MAP_STR_STR params2; + Want want2 = SystemTestFormUtil::MakeWant("device", abilityName2, bundleName2, params2); + SystemTestFormUtil::StartAbility(want2, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData2 = data; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_DELETE_FORM_0600, 600, eventData2); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_0600, 600)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_0600, 600); + bool result = data2 == "true"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_deleteForm_0600, result:" << result; + } + } + SystemTestFormUtil::CleanMsg(event); + + std::cout << "============END FMS_deleteForm_0600" << std::endl; +} + +/** + * @tc.number: FMS_deleteForm_0700 + * @tc.name: 删除常态卡片且删除后卡片引用为0，删除卡片后FMS中还有已创建的常态卡片。 + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.卡片使用方A，B分别创建1张常态卡片 + * 3.设置下面删除卡片参数： + * ·formId：卡片使用方A已创建卡片ID + * 测试步骤: + * 1.卡片使用方A调用删除卡片接口。 + * 2.验证卡片定时服务是否被停止。 + * 3.验证卡片缓存数据是否被删除。 + * 4.验证卡片持久化数据是否被删除。 + * 5.验证卡片提供方能够收到卡片删除通知。 + * 6.验证删除卡片接口返回成功。 + * 预期结果: + * 1.卡片定时服务被停止。 + * 2.卡片缓存数据被删除。 + * 3.卡片持久化数据被删除。 + * 4.卡片提供方能够收到卡片删除通知。 + * 5.删除卡片接口返回成功。 + */ +HWTEST_F(FormDeleteFormTest, FMS_deleteForm_0700, Function | MediumTest | Level1) +{ + std::cout << "============START FMS_deleteForm_0700" << std::endl; + std::string bundleName = "com.ohos.form.manager.commona"; + std::string abilityName = "FormAbilityCommonA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = "false"; //normal form + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ONE_NORMAL_FORM, 100, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100); + + GTEST_LOG_(INFO) << "FMS_deleteForm_0700, data:[" << data << "]" << std::endl; + if (data != "") { + std::string bundleName2 = "com.ohos.form.manager.normal"; + std::string abilityName2 = "FormAbilityDeleteForm"; + MAP_STR_STR params2; + Want want2 = SystemTestFormUtil::MakeWant("device", abilityName2, bundleName2, params2); + SystemTestFormUtil::StartAbility(want2, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData2 = data; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_DELETE_FORM_0700, 700, eventData2); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_0700, 700)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_0700, 700); + bool result = data2 == "true"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_deleteForm_0700, result:" << result; + } + } + SystemTestFormUtil::CleanMsg(event); + + std::cout << "============END FMS_deleteForm_0700" << std::endl; +} + +/** + * @tc.number: FMS_deleteForm_0800 + * @tc.name: 删除常态卡片且删除卡片后FMS中没有已创建的常态卡片。 + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.卡片使用方创建1张常态卡片 + * 3.设置下面删除卡片参数： + * ·formId：已创建卡片ID + * 测试步骤: + * 1.卡片使用方调用删除卡片接口。 + * 2.验证卡片定时服务是否被停止。 + * 3.验证定时器是否被销毁。 + * 4.验证卡片缓存数据是否被删除。 + * 5.验证卡片持久化数据是否被删除。 + * 6.验证卡片提供方能够收到卡片删除通知。 + * 7.验证删除卡片接口返回成功。 + * 预期结果: + * 1.卡片定时服务被停止。 + * 2.定时器被销毁。 + * 3.卡片缓存数据被删除。 + * 4.卡片持久化数据被删除。 + * 5.卡片提供方能够收到卡片删除通知。 + * 6.删除卡片接口返回成功。 + */ +HWTEST_F(FormDeleteFormTest, FMS_deleteForm_0800, Function | MediumTest | Level1) +{ + std::cout << "============START FMS_deleteForm_0800" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityDeleteForm"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_DELETE_FORM_0800; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_DELETE_FORM_0800, 800, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_0800, 800)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_0800, 800); + bool result = data == "true"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_deleteForm_0800, result:" << result; + } + SystemTestFormUtil::CleanMsg(event); + + std::cout << "============END FMS_deleteForm_0800" << std::endl; +} + +/** + * @tc.number: FMS_deleteForm_0900 + * @tc.name: 卡片ID错误（formId不存在） + * @tc.desc: + * 预置条件: + * 1.卡片使用方A有卡片使用权限 + * 2.卡片使用方A创建1张常态卡片 + * 3.卡片使用方A删除已创建卡片 + * 4.设置下面删除卡片参数： + * 测试步骤: + * 1.卡片使用方A调用删除卡片接口。 + * 2.验证删除卡片接口返回结果。 + * 预期结果: 删除卡片接口返回失败。（错误原因：卡片ID不存在） + */ +HWTEST_F(FormDeleteFormTest, FMS_deleteForm_0900, Function | MediumTest | Level1) +{ + std::cout << "============START FMS_deleteForm_0900" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityDeleteForm"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_DELETE_FORM_0900; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_DELETE_FORM_0900, 900, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_0900, 900)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_0900, 900); + bool result = data == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_deleteForm_0900, result:" << result; + } + SystemTestFormUtil::CleanMsg(event); + + std::cout << "============END FMS_deleteForm_0900" << std::endl; +} + +/** + * @tc.number: FMS_deleteForm_1000 + * @tc.name: 释放卡片后能够进行删除卡片 + * @tc.desc: + * 预置条件: + * 1.卡片使用方A有卡片使用权限 + * 2.卡片使用方A创建1张常态卡片 + * 3.卡片使用方A释放已创建卡片 + * 4.设置下面删除卡片参数： + * ·formId：3释放的卡片ID + * 测试步骤: + * 1.卡片使用方A调用删除卡片接口。 + * 2.验证删除卡片接口返回结果。 + * 预期结果: 删除卡片接口返回成功。 + */ +HWTEST_F(FormDeleteFormTest, FMS_deleteForm_1000, Function | MediumTest | Level1) +{ + std::cout << "============START FMS_deleteForm_1000" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityDeleteForm"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_DELETE_FORM_1000; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_DELETE_FORM_1000, 1000, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_1000, 1000)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_1000, 1000); + bool result = data == "true"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_deleteForm_1000, result:" << result; + } + SystemTestFormUtil::CleanMsg(event); + + std::cout << "============END FMS_deleteForm_1000" << std::endl; +} + +/** + * @tc.number: FMS_deleteForm_1100 + * @tc.name: 删除临时卡片时，卡片缓存数据被删除。 + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.卡片使用方A，B分别创建1张临时卡片 + * 3.设置下面删除卡片参数： + * ·formId：卡片使用方A已创建卡片ID + * 测试步骤: + * 1.卡片使用方A调用删除卡片接口。 + * 2.验证卡片缓存数据是否被删除。 + * 3.验证卡片提供方是否收到卡片删除通知。 + * 4.验证删除卡片接口返回成功。 + * 预期结果: + * 1.使用方A卡片缓存数据被删除，使用方B未被删除。 + * 2.卡片提供方能够收到卡片删除通知。 + * 3.删除卡片接口返回成功。 + */ +HWTEST_F(FormDeleteFormTest, FMS_deleteForm_1100, Function | MediumTest | Level1) +{ + std::cout << "============START FMS_deleteForm_1100" << std::endl; + + std::string bundleName = "com.ohos.form.manager.commona"; + std::string abilityName = "FormAbilityCommonA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = "true"; //temp form + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ONE_NORMAL_FORM, 100, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100); + + GTEST_LOG_(INFO) << "FMS_deleteForm_1100, data:[" << data << "]" << std::endl; + if (data != "") { + std::string bundleName2 = "com.ohos.form.manager.normal"; + std::string abilityName2 = "FormAbilityDeleteForm"; + MAP_STR_STR params2; + Want want2 = SystemTestFormUtil::MakeWant("device", abilityName2, bundleName2, params2); + SystemTestFormUtil::StartAbility(want2, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData2 = data; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_DELETE_FORM_1100, 1100, eventData2); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_DELETE_FORM_1100, 1100)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_DELETE_FORM_1100, 1100); + bool result = data2 == "true"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_deleteForm_1100, result:" << result; + } + } + SystemTestFormUtil::CleanMsg(event); + + std::cout << "============END FMS_deleteForm_1100" << std::endl; +} + +/** + * @tc.number: FMS_deleteForm_1200 + * @tc.name: 单使用方（使用单线程）连续删除多个常态和临时卡片 + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.存在单使用方已创建的常态卡片和临时卡片各5张 + * 测试步骤: + * 1.单使用方（利用单线程）连续10次删除卡片接口，删除全部10张卡片。 + * 2.验证全部删除卡片接口返回结果。 + * 预期结果: 删除卡片接口返回成功。 + */ +HWTEST_F(FormDeleteFormTest, FMS_deleteForm_1200, Function | MediumTest | Level2) +{ + std::cout << "============START FMS_deleteForm_1200" << std::endl; + std::cout << "============END FMS_deleteForm_1200" << std::endl; +} + +/** + * @tc.number: FMS_deleteForm_1400 + * @tc.name: 多使用方分别删除常态和临时卡片 + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.存在使用方A，B分别创建不同种类的常态卡片和临时卡片各5张。 + * 测试步骤: + * 1.使用方A，B分别连续删除各自卡片。 + * 2.验证全部删除卡片接口返回结果。 + * 预期结果: 删除卡片接口返回成功。 + */ +HWTEST_F(FormDeleteFormTest, FMS_deleteForm_1400, Function | MediumTest | Level2) +{ + std::cout << "============START FMS_deleteForm_1400" << std::endl; + std::cout << "============END FMS_deleteForm_1400" << std::endl; +} + +/** + * @tc.number: FMS_deleteForm_1500 + * @tc.name: 临时卡片达到256张后可以进行删除卡片及创建卡片 + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.FMS中已创建256张临时卡片 + * 测试步骤: + * 1.卡片使用方调用删除卡片接口，删除1张已创建的临时卡片。 + * 2.验证删除卡片接口返回结果。 + * 3.卡片使用方调用创建卡片接口，创建1张临时卡片。 + * 4.验证创建卡片接口返回结果。 + * 预期结果: + * 1.删除卡片接口返回成功。 + * 2.创建卡片接口返回成功。 + */ +HWTEST_F(FormDeleteFormTest, FMS_deleteForm_1500, Function | MediumTest | Level2) +{ + std::cout << "============START FMS_deleteForm_1500" << std::endl; + std::cout << "============END FMS_deleteForm_1500" << std::endl; +} + +/** + * @tc.number: FMS_deleteForm_1600 + * @tc.name: 单使用方常态卡片达到256张后可以进行删除卡片及创建卡片 + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.单使用方已创建256张常态卡片 + * 测试步骤: + * 1.卡片使用方调用删除卡片接口，删除1张已创建常态卡片。 + * 2.验证删除卡片接口返回结果。 + * 3.卡片使用方调用创建卡片接口，创建1张常态卡片。 + * 4.验证创建卡片接口返回结果。 + * 预期结果: + * 1.删除卡片接口返回成功。 + * 2.创建卡片接口返回成功。 + */ +HWTEST_F(FormDeleteFormTest, FMS_deleteForm_1600, Function | MediumTest | Level2) +{ + std::cout << "============START FMS_deleteForm_1600" << std::endl; + std::cout << "============END FMS_deleteForm_1600" << std::endl; +} + +/** + * @tc.number: FMS_deleteForm_1700 + * @tc.name: 多使用方常态卡片达到512张后可以进行删除卡片及创建卡片 + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.多使用方常态卡片达到512张（卡片使用方A已创建200张。卡片使用方B已创建200张，卡片使用方C已创建112张） + * 测试步骤: + * 1.卡片使用方C调用删除卡片接口，删除1张已创建常态卡片。 + * 2.验证删除卡片接口返回结果。 + * 3.卡片使用方C调用创建卡片接口，创建1张常态卡片。 + * 4.验证创建卡片接口返回结果。 + * 预期结果: + * 1.删除卡片接口返回成功。 + * 2.创建卡片接口返回成功。 + */ +HWTEST_F(FormDeleteFormTest, FMS_deleteForm_1700, Function | MediumTest | Level2) +{ + std::cout << "============START FMS_deleteForm_1700" << std::endl; + std::cout << "============END FMS_deleteForm_1700" << std::endl; +} + +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/systemtest/common/fms/fms_fuzz_test/BUILD.gn b/test/systemtest/common/fms/fms_fuzz_test/BUILD.gn new file mode 100644 index 0000000000..4258e11b0d --- /dev/null +++ b/test/systemtest/common/fms/fms_fuzz_test/BUILD.gn @@ -0,0 +1,73 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/appexecfwk/standard/appexecfwk.gni") + +module_output_path = "appexecfwk_standard/formmanagerst" + +ohos_systemtest("formManagerFuzzTest") { + module_out_path = module_output_path + include_dirs = [ + "${aafwk_path}/interfaces/innerkits/ability_manager/include", + "${appexecfwk_path}/test/systemtest/common/fms/fms_fuzz_test/include", + "//base/notification/ces_standard/test/systemtest/common/resource", + "//foundation/distributedschedule/safwk/services/safwk/include", + ] + + sources = [ + "src/fms_fuzz_test.cpp", + "src/fuzz_test_manager.cpp", + "src/get_param.cpp", + ] + + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + + configs = [ + "${aafwk_path}/services/abilitymgr:abilityms_config", + "${appexecfwk_path}/services/appmgr:appmgr_config", + ] + + deps = [ + "${aafwk_path}/frameworks/kits/ability/native:abilitykit_native", + "${aafwk_path}/services/abilitymgr:abilityms", + "${appexecfwk_path}/common:libappexecfwk_common", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//third_party/googletest:gtest_main", + ] + + defines = [ "APP_LOG_TAG = \"formManagerFuzzTest\"" ] + + external_deps = [ + "aafwk_standard:base", + "aafwk_standard:want", + "appexecfwk_standard:appexecfwk_base", + "appexecfwk_standard:appexecfwk_core", + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr_L2:samgr_proxy", + ] +} + +group("systemtest") { + testonly = true + + deps = [ ":formManagerFuzzTest" ] +} diff --git a/test/systemtest/common/fms/fms_fuzz_test/fms_fuzz_test_config/config.json b/test/systemtest/common/fms/fms_fuzz_test/fms_fuzz_test_config/config.json new file mode 100644 index 0000000000..cddf5115eb --- /dev/null +++ b/test/systemtest/common/fms/fms_fuzz_test/fms_fuzz_test_config/config.json @@ -0,0 +1,29 @@ +{ + "ExecutionTimes": 10, + "FormManagerAbility": { + "ReleaseForm": [], + "DeleteForm": [], + "AcquireForm": [], + "UpdateForm": [], + "CastTempForm": [], + "NotifyVisibleForms": [], + "NotifyInvisibleForms": [], + "SetFormNextRefreshTime": [], + "RequestForm":[], + "EnableUpdateForm": [], + "DisableUpdateForm": [], + "CheckFMSReady": [], + "GetAllFormsInfo":[], + "GetFormsInfoByApp": [], + "GetFormsInfoByModule": [], + "ProcessFormUpdate": [], + "ProcessFormUninstall": [], + "OnDeathReceived":[], + "OnCreate": [], + "OnDelete": [], + "OnCastTemptoNormal":[], + "OnUpdate": [], + "OnVisibilityChanged": [], + "OnTriggerEvent": [] + } +} diff --git a/test/systemtest/common/fms/fms_fuzz_test/include/fuzz_test_config_parser.h b/test/systemtest/common/fms/fms_fuzz_test/include/fuzz_test_config_parser.h new file mode 100644 index 0000000000..dd6e2bae42 --- /dev/null +++ b/test/systemtest/common/fms/fms_fuzz_test/include/fuzz_test_config_parser.h @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef FUZZ_CONFIG_PARSER_H +#define FUZZ_CONFIG_PARSER_H + +#include +#include +#include +#include + +#include "nlohmann/json.hpp" + +namespace OHOS { + +const std::string FUZZ_TEST_CONFIG_FILE_PATH{"./config.json"}; + +const std::string FUZZ_TEST_MAIN_LOOP_KEY{"ExecutionTimes"}; + +struct FuzzTestData { + int32_t mainLoopFlag{0}; + std::vector methodVec{}; +}; + +class FuzzTestConfigParser { +public: + void ParseForFuzzTest(const std::string &path, FuzzTestData &ftd) + { + std::cout << __func__ << std::endl; + if (path.empty()) { + std::cout << __FUNCTION__ << " invalid file path, check!" << std::endl; + return; + } + + nlohmann::json jsonObj; + std::ifstream(path) >> jsonObj; + std::cout << path; + for (auto it = jsonObj.begin(); it != jsonObj.end(); ++it) { + if (!it.key().compare(FUZZ_TEST_MAIN_LOOP_KEY)) { + ftd.mainLoopFlag = it.value(); + continue; + } + + auto className = it.key(); + if (it->is_structured()) { + for (auto itm = it->begin(); itm != it->end(); ++itm) { + auto methodName = itm.key(); + + if (!(it->is_structured() && (it->size() != 0))) { + ftd.methodVec.push_back(className + methodName); + continue; + } + + std::string param{}; + for (auto itp = itm->begin(); itp != itm->end(); ++itp) { + auto tp = itp.value(); + param += tp; + } + ftd.methodVec.push_back(className + methodName + param); + } + } + } + } +}; + +} // namespace OHOS + +#endif // FUZZ_CONFIG_PARSER_H diff --git a/test/systemtest/common/fms/fms_fuzz_test/include/fuzz_test_manager.h b/test/systemtest/common/fms/fms_fuzz_test/include/fuzz_test_manager.h new file mode 100644 index 0000000000..107b9130a8 --- /dev/null +++ b/test/systemtest/common/fms/fms_fuzz_test/include/fuzz_test_manager.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef FormManagerFuzzTest_H +#define FormManagerFuzzTest_H + +#include +#include +#include +#include + +#include "nlohmann/json.hpp" +namespace OHOS { +namespace AppExecFwk { + +class FormManagerFuzzTest { +public: + typedef std::shared_ptr Ptr; + ~FormManagerFuzzTest() + {} + static Ptr GetInstance() + { + if (fuzzTestInstance == nullptr) { + fuzzTestInstance = std::shared_ptr(new FormManagerFuzzTest); + } + return fuzzTestInstance; + } + + void StartFuzzTest(); + +private: + void SetJsonFunction(std::string); + void SetExecutionTimes(uint16_t executionTimes); + FormManagerFuzzTest(); + FormManagerFuzzTest(FormManagerFuzzTest &) = delete; + FormManagerFuzzTest &operator=(const FormManagerFuzzTest &) = delete; + static Ptr fuzzTestInstance; + uint16_t m_executionTimes{}; + std::unordered_map remainderMap_{}; + std::unordered_map> callFunctionMap_{}; + + void RegisterFormManagerAbility(); +}; +} // namespace AppExecFwk +} // namespace OHOS + +#endif \ No newline at end of file diff --git a/test/systemtest/common/fms/fms_fuzz_test/include/get_param.h b/test/systemtest/common/fms/fms_fuzz_test/include/get_param.h new file mode 100644 index 0000000000..df19f3c3f2 --- /dev/null +++ b/test/systemtest/common/fms/fms_fuzz_test/include/get_param.h @@ -0,0 +1,394 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef GET_PARAM_H +#define GET_PARAM_H +#include +#include +#include +#include + +#include "ability.h" +#include "pac_map.h" +#include "parcel.h" +#include "patterns_matcher.h" +#include "uri.h" +#include "want.h" +#include "form_info.h" +#include "form_js_info.h" + +namespace OHOS { +namespace AppExecFwk { +//class TestDumper; +bool GetBoolParam(); +uint8_t GetU8Param(); +unsigned int GetUIntParam(); +uint16_t GetU16Param(); +uint32_t GetU32Param(); +uint64_t GetU64Param(); +int8_t GetS8Param(); +int16_t GetS16Param(); +int32_t GetS32Param(); +int64_t GetS64Param(); +char32_t GetChar32Param(); + +short GetShortParam(); +long GetLongParam(); +int GetIntParam(); +double GetDoubleParam(); +float GetFloatParam(); +char GetCharParam(); +char *GetCharArryParam(); +std::string GetStringParam(); +std::map GetS64S32MapParam(); +std::vector GetBoolVectorParam(); +std::vector GetShortVectorParam(); +std::vector GetLongVectorParam(); +std::vector GetIntVectorParam(); +std::vector GetFloatVectorParam(); +std::vector GetDoubleVectorParam(); +std::vector GetCharVectorParam(); +std::vector GetChar32VectorParam(); +std::vector GetStringVectorParam(); +template +std::vector GetUnsignVectorParam(); +std::vector GetS8VectorParam(); +std::vector GetS16VectorParam(); +std::vector GetS32VectorParam(); +std::vector GetS64VectorParam(); +std::shared_ptr GetParamAbility(); +OHOS::AppExecFwk::Want GetParamWant(); +OHOS::AppExecFwk::FormInfo GetParamFormInfo(); +std::vector GetmFormInfoVectorParam(); +OHOS::AppExecFwk::FormJsInfo GetParamFormJsInfo(); +std::shared_ptr GetParamFormCallback(); +sptr GetParamSptrAbility(); +OHOS::AppExecFwk::FormProviderData GetParamFormProviderData(); + +class FormManagerAbilityTest : public Ability { +public: + FormManagerAbilityTest(); + ~FormManagerAbilityTest(); + + bool ReleaseForm(const int64_t formId); + + /** + * @brief Releases an obtained form by its ID. + * + *

After this method is called, the form won't be available for use by the application, if isReleaseCache is + * false, this method is same as {@link #releaseForm(int)}, otherwise the Form Manager Service still store this + * form in the cache.

+ *

Permission: {@link ohos.security.SystemPermission#REQUIRE_FORM}

+ * + * @param formId Indicates the form ID. + * @param isReleaseCache Indicates whether to clear cache in service. + * @return Returns {@code true} if the form is successfully released; returns {@code false} otherwise. + * + *
    + *
  • The passed {@code formId} is invalid. Its value must be larger than 0.
    • + *
  • The specified form has not been added by the application.
    • + *
  • An error occurred when connecting to the Form Manager Service.
    • + *
  • The application is not granted with the {@link ohos.security.SystemPermission#REQUIRE_FORM} permission.
    • + *
  • The form has been obtained by another application and cannot be released by the current application.
    • + *
  • The form is being restored.
    • + *
+ */ + bool ReleaseForm(const int64_t formId, const bool isReleaseCache); + + /** + * @brief Deletes an obtained form by its ID. + * + *

After this method is called, the form won't be available for use by the application and the Form Manager + * Service no longer keeps the cache information about the form.

+ *

Permission: {@link ohos.security.SystemPermission#REQUIRE_FORM}

+ * + * @param formId Indicates the form ID. + * @return Returns {@code true} if the form is successfully deleted; returns {@code false} otherwise. + * + *
    + *
  • The passed {@code formId} is invalid. Its value must be larger than 0.
    • + *
  • The specified form has not been added by the application.
    • + *
  • An error occurred when connecting to the Form Manager Service.
    • + *
  • The application is not granted with the {@link ohos.security.SystemPermission#REQUIRE_FORM} permission.
    • + *
  • The form has been obtained by another application and cannot be deleted by the current application.
    • + *
  • The form is being restored.
    • + *
+ */ + bool DeleteForm(const int64_t formId); + + /** + * @brief The form callback. + */ + class FormCallback { + public: + + /** + * @brief Called to notify the application that the {@code FormJsInfo} instance has been obtained after + * the application called the asynchronous method {@link Ability#acquireForm(Want, FormCallback)}. + * The application must present the form information on a specific page in this callback. + * + * @param result Specifies whether the asynchronous form acquisition process is successful. + * {@link FormCallback#OHOS_FORM_ACQUIRE_SUCCESS} indicates that the form + * is successfully obtained, and other values indicate that the process fails. + * @param formJsInfo Indicates the obtained {@code FormJsInfo} instance. + */ + virtual void OnAcquired(const int32_t result, const FormJsInfo &formJsInfo) const = 0; + + /** + * @brief Called to notify the application that the {@code FormJsInfo} instance has been obtained after + * the application called the asynchronous method {@link Ability#acquireForm(Want, FormCallback)}. + * The application must present the form information on a specific page in this callback. + * + * @param result Specifies whether the asynchronous form acquisition process is successful. + * {@link FormCallback#OHOS_FORM_UPDATE_SUCCESS} indicates that the form is + * successfully obtained, and other values indicate that the process fails. + * @param formJsInfo Indicates the obtained {@code FormJsInfo} instance. + */ + virtual void OnUpdate(const int32_t result, const FormJsInfo &formJsInfo) const = 0; + + /** + * @brief Called to notify the application that the {@code Form} provider has been uninstalled and the + * corresponding + * {@code Form} instance is no longer available. + * + * @param formId Indicates the ID of the {@code Form} instance provided by the uninstalled form provider. + */ + virtual void OnFormUninstall(const int64_t formId) const = 0; + }; + + /** + * @brief Obtains a specified form that matches the application bundle name, module name, form name, and + * other related information specified in the passed {@code Want}. + * + *

This method is asynchronous. After the {@link FormJsInfo} instance is obtained. + * + * @param formId Indicates the form ID. + * @param want Indicates the detailed information about the form to be obtained, including the bundle name, + * module name, ability name, form name, form id, tempForm flag, form dimension, and form customize data. + * @param callback Indicates the callback to be invoked whenever the {@link FormJsInfo} instance is obtained. + * @return Returns {@code true} if the request is successfully initiated; returns {@code false} otherwise. + */ + bool AcquireForm(const int64_t formId, const Want &want, const std::shared_ptr callback); + + /** + * @brief Updates the content of a specified JS form. + * + *

This method is called by a form provider to update JS form data as needed. + * + * @param formId Indicates the form ID. + * @param formProviderData The data used to update the JS form displayed on the client. + * @return Returns {@code true} if the request is successfully initiated; returns {@code false} otherwise. + */ + bool UpdateForm(const int64_t formId, const FormProviderData &formProviderData); + + /** + * @brief Cast temp form with formId. + * + * @param formId Indicates the form's ID. + * + * @return Returns {@code true} if the form is successfully casted; returns {@code false} otherwise. + */ + bool CastTempForm(const int64_t formId); + + /** + * @brief Sends a notification to the form framework to make the specified forms visible. + * + *

After this method is successfully called, {@link Ability#OnVisibilityChanged(std::map)} + * will be called to notify the form provider of the form visibility change event.

+ * + * @param formIds Indicates the IDs of the forms to be made visible. + * @return Returns {@code true} if the request is successfully initiated; returns {@code false} otherwise. + */ + bool NotifyVisibleForms(const std::vector &formIds); + + /** + * @brief Sends a notification to the form framework to make the specified forms invisible. + * + *

After this method is successfully called, {@link Ability#OnVisibilityChanged(std::map)} + * will be called to notify the form provider of the form visibility change event.

+ * + * @param formIds Indicates the IDs of the forms to be made invisible. + * @return Returns {@code true} if the request is successfully initiated; returns {@code false} otherwise. + */ + bool NotifyInvisibleForms(const std::vector &formIds); + + /** + * @brief Set form next refresh time. + * + *

This method is called by a form provider to set refresh time. + * + * @param formId Indicates the ID of the form to set refresh time. + * @param nextTime Indicates the next time gap now in seconds, can not be litter than 300 seconds. + * @return Returns {@code true} if seting succeed; returns {@code false} otherwise. + */ + + bool SetFormNextRefreshTime(const int64_t formId, const int64_t nextTime); + + /** + * @brief Update form. + * + * @param formJsInfo Indicates the obtained {@code FormJsInfo} instance. + */ + void ProcessFormUpdate(const FormJsInfo &formJsInfo) override; + + /** + * @brief Uninstall form. + * + * @param formId Indicates the ID of the form to uninstall. + */ + void ProcessFormUninstall(const int64_t formId) override; + + /** + * @brief Called to reacquire form and update the form host after the death callback is received. + * + */ + void OnDeathReceived() override; + + /** + * @brief Called to return a FormProviderInfo object. + * + *

You must override this method if your ability will serve as a form provider to provide a form for clients. + * The default implementation returns nullptr.

+ * + * @param want Indicates the detailed information for creating a FormProviderInfo. + * The Want object must include the form ID, form name of the form, + * which can be obtained from Ability#PARAM_FORM_IDENTITY_KEY, + * Ability#PARAM_FORM_NAME_KEY, and Ability#PARAM_FORM_DIMENSION_KEY, + * respectively. Such form information must be managed as persistent data for further form + * acquisition, update, and deletion. + * + * @return Returns the created FormProviderInfo object. + */ + virtual FormProviderInfo OnCreate(const Want &want) override; + + /** + * @brief Called to notify the form provider that a specified form has been deleted. Override this method if + * you want your application, as the form provider, to be notified of form deletion. + * + * @param formId Indicates the ID of the deleted form. + * @return None. + */ + virtual void OnDelete(const int64_t formId) override; + + /** + * @brief Called when the form provider is notified that a temporary form is successfully converted to + * a normal form. + * + * @param formId Indicates the ID of the form. + * @return None. + */ + virtual void OnCastTemptoNormal(const int64_t formId) override; + + /** + * @brief Called to notify the form provider to update a specified form. + * + * @param formId Indicates the ID of the form to update. + * @return none. + */ + virtual void OnUpdate(const int64_t formId) override; + + /** + * @brief Called when the form provider receives form events from the fms. + * + * @param formEventsMap Indicates the form events occurred. The key in the Map object indicates the form ID, + * and the value indicates the event type, which can be either FORM_VISIBLE + * or FORM_INVISIBLE. FORM_VISIBLE means that the form becomes visible, + * and FORM_INVISIBLE means that the form becomes invisible. + * @return none. + */ + virtual void OnVisibilityChanged(const std::map &formEventsMap) override; + /** + * @brief Called to notify the form provider to update a specified form. + * + * @param formId Indicates the ID of the form to update. + * @param message Form event message. + */ + virtual void OnTriggerEvent(const int64_t formId, const std::string &message) override; + /** + * @brief Requests for form data update. + * + * This method must be called when the application has detected that a system setting item (such as the language, + * resolution, or screen orientation) being listened for has changed. Upon receiving the update request, the form + * provider automatically updates the form data (if there is any update) through the form framework, with the update + * process being unperceivable by the application. + * + * @param formId Indicates the ID of the form to update. + * @return Returns true if the update request is successfully initiated, returns false otherwise. + */ + bool RequestForm(const int64_t formId); + + /** + * @brief Requests for form data update, by passing a set of parameters (using Want) to the form provider. + * + * This method must be called when the application has detected that a system setting item (such as the language, + * resolution, or screen orientation) being listened for has changed. Upon receiving the update request, the form + * provider automatically updates the form data (if there is any update) through the form framework, with the update + * process being unperceivable by the application. + * + * @param formId Indicates the ID of the form to update. + * @param want Indicates a set of parameters to be transparently passed to the form provider. + * @return Returns true if the update request is successfully initiated, returns false otherwise. + */ + bool RequestForm(const int64_t formId, const Want &want); + /** + * @brief Enable form update. + * + * @param formIds formIds of hostclient. + */ + bool EnableUpdateForm(const std::vector &formIds); + + /** + * @brief Disable form update. + * + * @param formIds formIds of hostclient. + */ + bool DisableUpdateForm(const std::vector &formIds); + + /** + * @brief Check form manager service ready. + * + * @return Returns true if form manager service ready; returns false otherwise. + */ + bool CheckFMSReady(); + + /** + * @brief Get All FormsInfo. + * + * @param formInfos Returns the forms' information of all forms provided. + * @return Returns true if the request is successfully initiated; returns false otherwise. + */ + bool GetAllFormsInfo(std::vector &formInfos); + + /** + * @brief Get forms info by application name. + * + * @param bundleName Application name. + * @param formInfos Returns the forms' information of the specify application name. + * @return Returns true if the request is successfully initiated; returns false otherwise. + */ + bool GetFormsInfoByApp(std::string &bundleName, std::vector &formInfos); + + /** + * @brief Get forms info by application name and module name. + * + * @param bundleName Application name. + * @param moduleName Module name of hap. + * @param formInfos Returns the forms' information of the specify application name and module name. + * @return Returns true if the request is successfully initiated; returns false otherwise. + */ + bool GetFormsInfoByModule(std::string &bundleName, std::string &moduleName, std::vector &formInfos); +}; +} // namespace AppExecFwk +} // namespace OHOS +#endif \ No newline at end of file diff --git a/test/systemtest/common/fms/fms_fuzz_test/src/fms_fuzz_test.cpp b/test/systemtest/common/fms/fms_fuzz_test/src/fms_fuzz_test.cpp new file mode 100644 index 0000000000..a2ffd5e56d --- /dev/null +++ b/test/systemtest/common/fms/fms_fuzz_test/src/fms_fuzz_test.cpp @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include "app_log_wrapper.h" +#include "nlohmann/json.hpp" +#include "../include/fuzz_test_manager.h" +#include "../include/get_param.h" + +using namespace testing::ext; + +namespace OHOS { +namespace AppExecFwk { +class FormFuzzTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void FormFuzzTest::SetUpTestCase() +{ + std::cout << "FormFuzzTest SetUpTestCase" << std::endl; +} + +void FormFuzzTest::TearDownTestCase() +{ + std::cout << "FormFuzzTest TearDownTestCase" << std::endl; +} + +void FormFuzzTest::SetUp() +{ + std::cout << "FormFuzzTest SetUp" << std::endl; +} + +void FormFuzzTest::TearDown() +{ + std::cout << "FormFuzzTest TearDown" << std::endl; +} + +/** + * @tc.number: FMS_fuzztest_0100 + * @tc.name: form manager service stress test + * @tc.desc: 1.under root,there is a config.json + * 2../FormManagerFuzzTest; hilog > xxxx.log + */ +HWTEST_F(FormFuzzTest, FMS_fuzztest_0100, Function | MediumTest | Level1) +{ + std::cout << "Begin FMS_fuzztest_0100" << std::endl; + + FormManagerFuzzTest::GetInstance()->StartFuzzTest(); + + std::cout << "End FMS_fuzztest_0100" << std::endl; +} + +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/systemtest/common/fms/fms_fuzz_test/src/fuzz_test_manager.cpp b/test/systemtest/common/fms/fms_fuzz_test/src/fuzz_test_manager.cpp new file mode 100644 index 0000000000..21bc3be16c --- /dev/null +++ b/test/systemtest/common/fms/fms_fuzz_test/src/fuzz_test_manager.cpp @@ -0,0 +1,215 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#define private public +#define protected public + +#include "hilog_wrapper.h" +#include "ability.h" +#include "../include/get_param.h" +#include "../include/fuzz_test_manager.h" +#include "../include/fuzz_test_config_parser.h" +#include +#include + +#undef private +#undef protected +using namespace OHOS::AppExecFwk; +namespace OHOS { +namespace AppExecFwk { +std::shared_ptr FormManagerFuzzTest::fuzzTestInstance = nullptr; +const std::string formManagerAbilityKitName = "FormManagerAbility"; + +// RegisterFormManagerAbility +void FormManagerFuzzTest::RegisterFormManagerAbility() +{ + callFunctionMap_[formManagerAbilityKitName + "ReleaseForm"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->ReleaseForm(GetS64Param(),GetBoolParam()); + }; + callFunctionMap_[formManagerAbilityKitName + "DeleteForm"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->DeleteForm(GetS64Param()); + }; + callFunctionMap_[formManagerAbilityKitName + "AcquireForm"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->AcquireForm(GetS64Param(), GetParamWant(), GetParamFormCallback()); + }; + callFunctionMap_[formManagerAbilityKitName + "UpdateForm"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->UpdateForm(GetS64Param(), GetParamFormProviderData()); + }; + callFunctionMap_[formManagerAbilityKitName + "CastTempForm"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->CastTempForm(GetS64Param()); + }; + callFunctionMap_[formManagerAbilityKitName + "NotifyVisibleForms"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->NotifyVisibleForms(GetS64VectorParam()); + }; + callFunctionMap_[formManagerAbilityKitName + "NotifyInvisibleForms"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->NotifyInvisibleForms(GetS64VectorParam()); + }; + callFunctionMap_[formManagerAbilityKitName + "SetFormNextRefreshTime"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->SetFormNextRefreshTime(GetS64Param(), GetS64Param()); + }; + callFunctionMap_[formManagerAbilityKitName + "RequestForm"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->RequestForm(GetS64Param()); + }; + callFunctionMap_[formManagerAbilityKitName + "EnableUpdateForm"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->EnableUpdateForm(GetS64VectorParam()); + }; + callFunctionMap_[formManagerAbilityKitName + "DisableUpdateForm"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->DisableUpdateForm(GetS64VectorParam()); + }; + callFunctionMap_[formManagerAbilityKitName + "CheckFMSReady"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->CheckFMSReady(); + }; + callFunctionMap_[formManagerAbilityKitName + "GetAllFormsInfo"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + std::vector formInfos; + formManagerAbility->GetAllFormsInfo(formInfos); + }; + callFunctionMap_[formManagerAbilityKitName + "GetFormsInfoByApp"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + string bundleName = GetStringParam(); + std::vector formInfos; + formManagerAbility->GetFormsInfoByApp(bundleName, formInfos); + }; + callFunctionMap_[formManagerAbilityKitName + "GetFormsInfoByModule"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + string bundleName = GetStringParam(); + string moduleName = GetStringParam(); + std::vector formInfos; + formManagerAbility->GetFormsInfoByModule(bundleName, moduleName, formInfos); + }; + callFunctionMap_[formManagerAbilityKitName + "ProcessFormUpdate"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->ProcessFormUpdate(GetParamFormJsInfo()); + }; + callFunctionMap_[formManagerAbilityKitName + "ProcessFormUninstall"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->ProcessFormUninstall(GetS64Param()); + }; + callFunctionMap_[formManagerAbilityKitName + "OnDeathReceived"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->OnDeathReceived(); + }; + callFunctionMap_[formManagerAbilityKitName + "OnCreate"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->OnCreate(GetParamWant()); + }; + callFunctionMap_[formManagerAbilityKitName + "OnDelete"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->OnDelete(GetS64Param()); + }; + callFunctionMap_[formManagerAbilityKitName + "OnCastTemptoNormal"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->OnCastTemptoNormal(GetS64Param()); + }; + callFunctionMap_[formManagerAbilityKitName + "OnUpdate"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->OnUpdate(GetS64Param()); + }; + callFunctionMap_[formManagerAbilityKitName + "OnVisibilityChanged"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->OnVisibilityChanged(GetS64S32MapParam()); + }; + callFunctionMap_[formManagerAbilityKitName + "OnTriggerEvent"] = []() { + std::shared_ptr formManagerAbility = GetParamAbility(); + formManagerAbility->OnTriggerEvent(GetS64Param(), GetStringParam()); + }; +} + +FormManagerFuzzTest::FormManagerFuzzTest() +{ + RegisterFormManagerAbility(); +} + +void FormManagerFuzzTest::SetJsonFunction(std::string functionName) +{ + remainderMap_.emplace(functionName, m_executionTimes); +} + +void FormManagerFuzzTest::SetExecutionTimes(uint16_t executionTimes) +{ + m_executionTimes = executionTimes; + for_each(remainderMap_.begin(), remainderMap_.end(), [executionTimes](std::unordered_map::reference executionTimesTemp) { + executionTimesTemp.second = executionTimes; + }); +} + +int GetRandomInt(int minNum, int maxNum) +{ + return GetU16Param() % (maxNum - minNum + 1) + minNum; +} + +void action(int a) +{ + std::cout << "Interrupt signal (" << a << ") received.\n"; +} + +void FormManagerFuzzTest::StartFuzzTest() +{ + std::cout << __func__ << std::endl; + OHOS::FuzzTestConfigParser jsonParser; + OHOS::FuzzTestData tempData; + + std::cout << "parseFromFile start" << std::endl; + jsonParser.ParseForFuzzTest(FUZZ_TEST_CONFIG_FILE_PATH, tempData); + std::cout << " ExecutionTimes :" << tempData.mainLoopFlag << std::endl; + for_each(tempData.methodVec.begin(), tempData.methodVec.end(), [this](std::vector::reference s) { + SetJsonFunction(s); + }); + SetExecutionTimes(tempData.mainLoopFlag); + + std::vector index; + std::unordered_map::iterator it = remainderMap_.begin(); + while (it != remainderMap_.end()) { + if (it->second <= 0) { + it = remainderMap_.erase(it); + } else { + index.push_back(it->first); + it++; + } + } + + std::cout << remainderMap_.size() << "--------fuzz test start--------" << callFunctionMap_.size() << std::endl; + for (; remainderMap_.size() > 0;) { + std::string functionName; + int offset = GetRandomInt(0, index.size() - 1); + functionName = index[offset]; + if (callFunctionMap_.find(functionName) != callFunctionMap_.end()) { + std::cout << "call function : " << functionName << std::endl; + callFunctionMap_[functionName](); + std::cout << "function end :" << functionName << std::endl; + } else { + std::cout << "can't find function : " << functionName << std::endl; + } + remainderMap_[functionName]--; + if (remainderMap_[functionName] <= 0) { + remainderMap_.erase(functionName); + index.erase(index.begin() + offset); + }; + } + std::cout << remainderMap_.size() << "--------fuzz test end--------" << std::endl; +} +} // namespace AppExecFwk +} // namespace OHOS diff --git a/test/systemtest/common/fms/fms_fuzz_test/src/get_param.cpp b/test/systemtest/common/fms/fms_fuzz_test/src/get_param.cpp new file mode 100644 index 0000000000..e73694a55d --- /dev/null +++ b/test/systemtest/common/fms/fms_fuzz_test/src/get_param.cpp @@ -0,0 +1,477 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "../include/get_param.h" +#include +#include +#include +#include +#include +#include "values_bucket.h" +#include "ability.h" + +using namespace std; +using namespace OHOS::AppExecFwk; +using Uri = OHOS::Uri; +namespace OHOS { +namespace AppExecFwk { +bool GetBoolParam() +{ + bool param; + if (GetIntParam() % 2 == 0) { + param = true; + } else { + param = false; + } + cout << "Bool param is: " << param << endl; + return param; +} + +size_t GenRandom(size_t min, size_t max) +{ + std::random_device rd; + static uniform_int_distribution u(min, max); + static default_random_engine e(rd()); + size_t param = u(e); + return param; +} + +int8_t GetS8Param() +{ + std::random_device rd; + static uniform_int_distribution u(INT8_MIN, INT8_MAX); + static default_random_engine e(rd()); + int8_t param = u(e); + cout << "Int8_t param is: " << param << endl; + return param; +} +int16_t GetS16Param() +{ + std::random_device rd; + static uniform_int_distribution u(INT16_MIN, INT16_MAX); + static default_random_engine e(rd()); + int16_t param = u(e); + cout << "Int16_t param is: " << param << endl; + return param; +} +int32_t GetS32Param() +{ + std::random_device rd; + static uniform_int_distribution u(INT32_MIN, INT32_MAX); + static default_random_engine e(rd()); + int32_t param = u(e); + cout << "Int32_t param is: " << param << endl; + return param; +} + +int64_t GetS64Param() +{ + std::random_device rd; + static uniform_int_distribution u(INT64_MIN, INT64_MAX); + static default_random_engine e(rd()); + int64_t param = u(e); + cout << "Int64_t param is: " << param << endl; + return param; +} + +template +T GetUnsignParam() +{ + std::random_device rd; + static uniform_int_distribution u; + static default_random_engine e(rd()); + T param = u(e); + return param; +} + +size_t GetSizeTParam() +{ + size_t param = GetUnsignParam(); + return param; +} + +uint8_t GetU8Param() +{ + uint8_t param = GetUnsignParam(); + cout << "Uint8_t param is: " << param << endl; + return param; +} + +unsigned int GetUIntParam() +{ + unsigned int param = GetUnsignParam(); + cout << "Unsigned int param is: " << param << endl; + return param; +} + +uint16_t GetU16Param() +{ + uint16_t param = GetUnsignParam(); + cout << "Uint16_t param is: " << param << endl; + return param; +} + +uint32_t GetU32Param() +{ + uint32_t param = GetUnsignParam(); + cout << "Uint32_t param is: " << param << endl; + return param; +} + +uint64_t GetU64Param() +{ + uint64_t param = GetUnsignParam(); + cout << "Uint64_t param is: " << param << endl; + return param; +} + +short GetShortParam() +{ + std::random_device rd; + static uniform_int_distribution u(SHRT_MIN, SHRT_MAX); + static default_random_engine e(rd()); + short param = u(e); + cout << "Short param is: " << param << endl; + return param; +} + +long GetLongParam() +{ + std::random_device rd; + static uniform_int_distribution u(LONG_MIN, LONG_MAX); + static default_random_engine e(rd()); + long param = u(e); + cout << "Long param is: " << param << endl; + return param; +} + +int GetIntParam() +{ + std::random_device rd; + static uniform_int_distribution<> u(INT_MIN, INT_MAX); + static default_random_engine e(rd()); + int param = u(e); + cout << "Int param is: " << param << endl; + return param; +} + +double GetDoubleParam() +{ + double param = 0; + std::random_device rd; + static uniform_real_distribution u(DBL_MIN, DBL_MAX); + static default_random_engine e(rd()); + param = u(e); + cout << "double param is: " << param << endl; + return param; +} + +float GetFloatParam() +{ + float param = 0; + std::random_device rd; + static uniform_real_distribution u(FLT_MIN, FLT_MAX); + static default_random_engine e(rd()); + param = u(e); + cout << "Float param is: " << param << endl; + return param; +} + +char GetCharParam() +{ + std::random_device rd; + static uniform_int_distribution<> u(-128, 127); + static default_random_engine e(rd()); + char param = u(e); + return param; +} + +char32_t GetChar32Param() +{ + char32_t param = ' '; + std::random_device rd; + static uniform_int_distribution u; + static default_random_engine e(rd()); + param = u(e); + return param; +} + +char *GetCharArryParam() +{ + static char param[256]; + size_t len = 0; + string strparam = GetStringParam(); + if (!strparam.empty()) { + len = strparam.size() + 1; + if (len > sizeof(param)) { + len = sizeof(param) - 1; + } + + int ret = strcpy_s(param, len, strparam.c_str()); + if(ret == 0){ + return param; + } else { + return nullptr; + } + } else { + return nullptr; + } +} + +string GetStringParam() +{ + string param = ""; + char ch = GetCharParam(); + size_t len = GenRandom(0, 255); + while (len--) { + ch = GetCharParam(); + param += ch; + } + cout << "String param length is: " << param.length() << endl; + return param; +} + +std::map GetS64S32MapParam() +{ + map param; + size_t len = GenRandom(0, 255); + while (len--) { + int64_t int64Value = GetS64Param(); + int32_t int32Value = GetS32Param(); + param.insert(pair(int64Value, int32Value)); + } + cout << "int64_t, int32_t map param length is: " << param.size() << endl; + return param; +} + +template +vector GetUnsignVectorParam() +{ + vector param; + size_t len = GenRandom(0, 255); + while (len--) { + T t = GetUnsignParam(); + param.push_back(t); + } + cout << "Uint vector param length is: " << param.size() << endl; + return param; +} + +template +T GetClassParam() +{ + T param; + return param; +} + +std::vector GetBoolVectorParam() +{ + vector param; + size_t len = GenRandom(0, 255); + while (len--) { + int t = GetBoolParam(); + param.push_back(t); + } + cout << "Bool vector param length is: " << param.size() << endl; + return param; +} + +std::vector GetShortVectorParam() +{ + vector param; + size_t len = GenRandom(0, 255); + while (len--) { + short t = GetShortParam(); + param.push_back(t); + } + cout << "Short vector param length is: " << param.size() << endl; + return param; +} + +std::vector GetLongVectorParam() +{ + vector param; + size_t len = GenRandom(0, 255); + while (len--) { + long t = GetLongParam(); + param.push_back(t); + } + cout << "Long vector param length is: " << param.size() << endl; + return param; +} + +vector GetIntVectorParam() +{ + vector param; + size_t len = GenRandom(0, 255); + while (len--) { + int t = GetIntParam(); + param.push_back(t); + } + cout << "Int vector param length is: " << param.size() << endl; + return param; +} + +std::vector GetFloatVectorParam() +{ + vector param; + size_t len = GenRandom(0, 255); + while (len--) { + float t = GetIntParam(); + param.push_back(t); + } + cout << "Float vector param length is: " << param.size() << endl; + return param; +} + +std::vector GetDoubleVectorParam() +{ + vector param; + size_t len = GenRandom(0, 255); + while (len--) { + double t = GetIntParam(); + param.push_back(t); + } + cout << "Double vector param length is: " << param.size() << endl; + return param; +} + +vector GetCharVectorParam() +{ + vector param; + size_t len = GenRandom(0, 255); + while (len--) { + char t = GetCharParam(); + param.push_back(t); + } + cout << "Char vector param length is: " << param.size() << endl; + return param; +} + +vector GetChar32VectorParam() +{ + vector param; + size_t len = GenRandom(0, 255); + while (len--) { + char32_t t = GetChar32Param(); + param.push_back(t); + } + cout << "Char32_t vector param length is: " << param.size() << endl; + return param; +} + +vector GetStringVectorParam() +{ + vector param; + size_t len = GenRandom(0, 255); + while (len--) { + string t = GetStringParam(); + param.push_back(t); + } + cout << "String vector param length is: " << param.size() << endl; + return param; +} + +vector GetS8VectorParam() +{ + vector param; + size_t len = GenRandom(0, 255); + while (len--) { + int8_t temp = GetS8Param(); + param.push_back(temp); + } + cout << "Int8_t vector param length is: " << param.size() << endl; + return param; +} + +vector GetS16VectorParam() +{ + vector param; + size_t len = GenRandom(0, 255); + while (len--) { + int16_t temp = GetS16Param(); + param.push_back(temp); + } + cout << "Int16_t vector param length is: " << param.size() << endl; + return param; +} + +vector GetS32VectorParam() +{ + vector param; + size_t len = GenRandom(0, 255); + while (len--) { + int32_t temp = GetS32Param(); + param.push_back(temp); + } + cout << "Int32_t vector param length is: " << param.size() << endl; + return param; +} + +vector GetS64VectorParam() +{ + vector param; + size_t len = GenRandom(0, 255); + while (len--) { + int64_t temp = GetS64Param(); + param.push_back(temp); + } + cout << "Int32_t vector param length is: " << param.size() << endl; + return param; +} + +std::shared_ptr GetParamAbility() +{ + return make_shared(); +} + +OHOS::AppExecFwk::Want GetParamWant() +{ + return OHOS::AppExecFwk::Want(); +} + +OHOS::AppExecFwk::FormInfo GetParamFormInfo() +{ + return OHOS::AppExecFwk::FormInfo(); +} + +OHOS::AppExecFwk::FormJsInfo GetParamFormJsInfo() +{ + return OHOS::AppExecFwk::FormJsInfo(); +} + +std::shared_ptr GetParamFormCallback() +{ + return shared_ptr(); +} + +OHOS::AppExecFwk::FormProviderData GetParamFormProviderData() +{ + return OHOS::AppExecFwk::FormProviderData(); +} + +std::vector GetmFormInfoVectorParam() +{ + vector param; + size_t len = GenRandom(0, 255); + while (len--) { + OHOS::AppExecFwk::FormInfo t = GetParamFormInfo(); + param.push_back(t); + } + cout << "FormInfo vector param length is: " << param.size() << endl; + return param; +} + +} // namespace AppExecFwk +} // namespace OHOS diff --git a/test/systemtest/common/fms/fms_fuzz_test/test_lib/formManagerFuzzTest b/test/systemtest/common/fms/fms_fuzz_test/test_lib/formManagerFuzzTest new file mode 100644 index 0000000000000000000000000000000000000000..dab3f2bc86df074aa25c6b7e49d22f8cdaedd700 GIT binary patch literal 246288 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 +#include +#include +#include +#include +#include + +#include "app_log_wrapper.h" +#include "ability_info.h" +#include "ability_handler.h" +#include "ability_local_record.h" +#include "ability_start_setting.h" +#include "common_event.h" +#include "common_event_manager.h" +#include "context_deal.h" +#include "form_event.h" +#include "form_st_common_info.h" +#include "form_st_util.h" +#include "iservice_registry.h" +#include "nlohmann/json.hpp" +#include "system_ability_definition.h" +#include "performance_config_parser.h" + +using OHOS::AAFwk::Want; +using namespace testing::ext; +using namespace std::chrono_literals; +using namespace OHOS::STtools; + +namespace { +std::vector bundleNameList = { + "com.ohos.form.manager.performance", +}; +std::vector hapNameList = { + "fms_performance_test-signed", +}; +} // namespace + +namespace OHOS { +namespace AppExecFwk { + +static PerformanceLevel pLevel_; +static int64_t totalTime = 0; +const std::string TEST_RESULT_PATH = "./performance_test_result.txt"; + +class FormPerformanceTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + static bool SubscribeEvent(); + static bool PublishEvent(const std::string &eventName, const int &code, const std::string &data); + static bool SavePerformanceTestResult(const std::string &testcase, const int64_t &timeValue); + + void SetUp(); + void TearDown(); + void StartAbilityKitTest(const std::string &abilityName, const std::string &bundleName); + void TerminateAbility(const std::string &eventName, const std::string &abilityName); + + // Test case + static void PerformanceTest_0100(); + static void PerformanceTest_0200(); + static void PerformanceTest_0300(); + static void PerformanceTest_0400(); + static void PerformanceTest_0500(); + static void PerformanceTest_0600(); + static void PerformanceTest_0700(); + static void PerformanceTest_1300(); + static void PerformanceTest_1400(); + static void PerformanceTest_1500(); + static void PerformanceTest_1600(); + + class FormEventSubscriber : public CommonEventSubscriber { + public: + explicit FormEventSubscriber(const CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp){}; + virtual void OnReceiveEvent(const CommonEventData &data) override; + ~FormEventSubscriber() = default; + }; + + static sptr abilityMs; + static FormEvent event; + static std::vector eventList; + static std::shared_ptr subscriber_; + +}; + +std::vector FormPerformanceTest::eventList = { + FORM_EVENT_ABILITY_ONACTIVED, FORM_EVENT_RECV_PERFORMANCE_TEST_0100, FORM_EVENT_RECV_PERFORMANCE_TEST_0200, + FORM_EVENT_RECV_PERFORMANCE_TEST_0300, FORM_EVENT_RECV_PERFORMANCE_TEST_0400, FORM_EVENT_RECV_PERFORMANCE_TEST_0500, + FORM_EVENT_RECV_PERFORMANCE_TEST_0600, FORM_EVENT_RECV_PERFORMANCE_TEST_0700, FORM_EVENT_RECV_PERFORMANCE_TEST_1300, + FORM_EVENT_RECV_PERFORMANCE_TEST_1400, FORM_EVENT_RECV_PERFORMANCE_TEST_1500, FORM_EVENT_RECV_PERFORMANCE_TEST_1600, +}; + +bool PublishEvent(const std::string &eventName, const int &code, const std::string &data) +{ + Want want; + want.SetAction(eventName); + CommonEventData commonData; + commonData.SetWant(want); + commonData.SetCode(code); + commonData.SetData(data); + return CommonEventManager::PublishCommonEvent(commonData); +} + +FormEvent FormPerformanceTest::event = FormEvent(); +sptr FormPerformanceTest::abilityMs = nullptr; +std::shared_ptr FormPerformanceTest::subscriber_ = nullptr; +void FormPerformanceTest::FormEventSubscriber::OnReceiveEvent(const CommonEventData &data) +{ + GTEST_LOG_(INFO) << "OnReceiveEvent: event=" << data.GetWant().GetAction(); + GTEST_LOG_(INFO) << "OnReceiveEvent: data=" << data.GetData(); + GTEST_LOG_(INFO) << "OnReceiveEvent: code=" << data.GetCode(); + SystemTestFormUtil::Completed(event, data.GetWant().GetAction(), data.GetCode(), data.GetData()); + + auto eventName = data.GetWant().GetAction(); + auto iter = std::find(eventList.begin(), eventList.end(), eventName); + if (iter != eventList.end()) { + SystemTestFormUtil::Completed(event, data.GetData(), data.GetCode()); + } +} + +bool FormPerformanceTest::SavePerformanceTestResult(const std::string &testcase, const int64_t &timeValue) +{ + std::ofstream o(TEST_RESULT_PATH, std::ios::app); + o.close(); + + std::fstream f(TEST_RESULT_PATH, std::ios::app); + if (f.good() == false) { + return false; + } + + f << std::setw(4) << testcase << " consuming:" << timeValue << " ms" << std::endl; + + f.close(); + return true; +} + +void FormPerformanceTest::SetUpTestCase() +{ + SystemTestFormUtil::InstallHaps(hapNameList); + if (!SubscribeEvent()) { + GTEST_LOG_(INFO) << "SubscribeEvent error"; + } + + PerformanceConfigParser pcp; + pcp.ParseForPerformance(PERFORMANCE_CONFIG_FILE_PATH, pLevel_); + std::cout << "performance test level : " + << "executionTimes : " << pLevel_.executionTimesLevel << std::endl; +} + +void FormPerformanceTest::TearDownTestCase() +{ + SystemTestFormUtil::UninstallBundle(bundleNameList); + CommonEventManager::UnSubscribeCommonEvent(subscriber_); +} + +void FormPerformanceTest::SetUp() +{ + std::ofstream o(TEST_RESULT_PATH); + o.close(); + std::fstream f(TEST_RESULT_PATH); + if (f.good() == false) { + return; + } + f << std::setw(4) << "total execution times:" << pLevel_.executionTimesLevel << std::endl; + + f.close(); +} + +void FormPerformanceTest::TearDown() +{ + SystemTestFormUtil::CleanMsg(event); + + std::ofstream o(TEST_RESULT_PATH, std::ios::app); + o.close(); + std::fstream f(TEST_RESULT_PATH, std::ios::app); + if (f.good() == false) { + return; + } + f << std::setw(4) << "total time:" << totalTime << " ms" << std::endl; + + f.close(); +} +bool FormPerformanceTest::SubscribeEvent() +{ + MatchingSkills matchingSkills; + for (const auto &e : eventList) { + matchingSkills.AddEvent(e); + } + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + subscribeInfo.SetPriority(1); + subscriber_ = std::make_shared(subscribeInfo); + return CommonEventManager::SubscribeCommonEvent(subscriber_); +} + +void FormPerformanceTest::PerformanceTest_0100() +{ + struct timespec time1 = {0}; + struct timespec time2 = {0}; + int64_t usecTimesA = 1000000000; + int64_t usecTimesB = 1000000; + int64_t consuming = 0; + + clock_gettime(CLOCK_REALTIME,&time1); + + std::string bundleName = "com.ohos.form.manager.performance"; + std::string abilityName = "FormAbilityPerformance"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // AcquireForm + std::string eventData = FORM_EVENT_REQ_PERFORMANCE_TEST_0100; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_PERFORMANCE_TEST_0100, 100, eventData); + + // OnAcquired + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_PERFORMANCE_TEST_0100, 101)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_PERFORMANCE_TEST_0100, 101); + std::string formId = data; + + // OnUpdate + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_PERFORMANCE_TEST_0100, 102)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_PERFORMANCE_TEST_0100, 102); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + clock_gettime(CLOCK_REALTIME, &time2); + consuming = (time2.tv_sec * usecTimesA + time2.tv_nsec - (time1.tv_sec * usecTimesA + time1.tv_nsec)) / usecTimesB; + totalTime += consuming; + bool ret = FormPerformanceTest::SavePerformanceTestResult("FMS_performanceTest_0100", consuming); + std::cout << "SavePerformanceTestResult: "<< ret << "consuming:" << consuming << std::endl; + GTEST_LOG_(INFO) << "FMS_performanceTest_0100 AcquireForm, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} + +void FormPerformanceTest::PerformanceTest_0200() +{ + struct timespec time1 = {0}; + struct timespec time2 = {0}; + int64_t usecTimesA = 1000000000; + int64_t usecTimesB = 1000000; + int64_t consuming = 0; + + clock_gettime(CLOCK_REALTIME,&time1); + + std::string bundleName = "com.ohos.form.manager.performance"; + std::string abilityName = "FormAbilityPerformance"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // DeleteForm + std::string eventData = FORM_EVENT_REQ_PERFORMANCE_TEST_0100; + SystemTestFormUtil::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0200, 200, eventData); + + // DeleteForm Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_PERFORMANCE_TEST_0200, 200)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_PERFORMANCE_TEST_0200, 200); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + clock_gettime(CLOCK_REALTIME, &time2); + consuming = (time2.tv_sec * usecTimesA + time2.tv_nsec - (time1.tv_sec * usecTimesA + time1.tv_nsec)) / usecTimesB; + totalTime += consuming; + bool ret = FormPerformanceTest::SavePerformanceTestResult("FMS_performanceTest_0200", consuming); + std::cout << "SavePerformanceTestResult: "<< ret << "consuming:" << consuming << std::endl; + GTEST_LOG_(INFO) << "FMS_performanceTest_0200 DeleteForm, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} + +void FormPerformanceTest::PerformanceTest_0300() +{ + struct timespec time1 = {0}; + struct timespec time2 = {0}; + int64_t usecTimesA = 1000000000; + int64_t usecTimesB = 1000000; + int64_t consuming = 0; + + clock_gettime(CLOCK_REALTIME,&time1); + + std::string bundleName = "com.ohos.form.manager.performance"; + std::string abilityName = "FormAbilityPerformance"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // ReleaseForm + std::string eventData = FORM_EVENT_RECV_PERFORMANCE_TEST_0300; + SystemTestFormUtil::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0300, 300, eventData); + + // ReleaseForm Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_PERFORMANCE_TEST_0300, 300)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_PERFORMANCE_TEST_0300, 300); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + clock_gettime(CLOCK_REALTIME, &time2); + consuming = (time2.tv_sec * usecTimesA + time2.tv_nsec - (time1.tv_sec * usecTimesA + time1.tv_nsec)) / usecTimesB; + totalTime += consuming; + bool ret = FormPerformanceTest::SavePerformanceTestResult("FMS_performanceTest_0300", consuming); + std::cout << "SavePerformanceTestResult: "<< ret << "consuming:" << consuming << std::endl; + GTEST_LOG_(INFO) << "FMS_performanceTest_0300 ReleaseForm, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} + +void FormPerformanceTest::PerformanceTest_0400() +{ + struct timespec time1 = {0}; + struct timespec time2 = {0}; + int64_t usecTimesA = 1000000000; + int64_t usecTimesB = 1000000; + int64_t consuming = 0; + + clock_gettime(CLOCK_REALTIME,&time1); + + std::string bundleName = "com.ohos.form.manager.performance"; + std::string abilityName = "FormAbilityPerformance"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // CastTempForm + std::string eventData = FORM_EVENT_RECV_PERFORMANCE_TEST_0400; + SystemTestFormUtil::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0400, 400, eventData); + + // CastTempForm Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_PERFORMANCE_TEST_0400, 400)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_PERFORMANCE_TEST_0400, 400); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + clock_gettime(CLOCK_REALTIME, &time2); + consuming = (time2.tv_sec * usecTimesA + time2.tv_nsec - (time1.tv_sec * usecTimesA + time1.tv_nsec)) / usecTimesB; + totalTime += consuming; + bool ret = FormPerformanceTest::SavePerformanceTestResult("FMS_performanceTest_0400", consuming); + std::cout << "SavePerformanceTestResult: "<< ret << "consuming:" << consuming << std::endl; + GTEST_LOG_(INFO) << "FMS_performanceTest_0400 CastTempForm, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} + +void FormPerformanceTest::PerformanceTest_0500() +{ + struct timespec time1 = {0}; + struct timespec time2 = {0}; + int64_t usecTimesA = 1000000000; + int64_t usecTimesB = 1000000; + int64_t consuming = 0; + + clock_gettime(CLOCK_REALTIME,&time1); + + std::string bundleName = "com.ohos.form.manager.performance"; + std::string abilityName = "FormAbilityPerformance"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // NotifyVisibleForms + std::string eventData = FORM_EVENT_RECV_PERFORMANCE_TEST_0500; + SystemTestFormUtil::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0500, 500, eventData); + + // NotifyVisibleForms Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_PERFORMANCE_TEST_0500, 500)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_PERFORMANCE_TEST_0500, 500); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + clock_gettime(CLOCK_REALTIME, &time2); + consuming = (time2.tv_sec * usecTimesA + time2.tv_nsec - (time1.tv_sec * usecTimesA + time1.tv_nsec)) / usecTimesB; + totalTime += consuming; + bool ret = FormPerformanceTest::SavePerformanceTestResult("FMS_performanceTest_0500", consuming); + std::cout << "SavePerformanceTestResult: "<< ret << "consuming:" << consuming << std::endl; + GTEST_LOG_(INFO) << "FMS_performanceTest_0500 NotifyVisibleForms, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} + +void FormPerformanceTest::PerformanceTest_0600() +{ + struct timespec time1 = {0}; + struct timespec time2 = {0}; + int64_t usecTimesA = 1000000000; + int64_t usecTimesB = 1000000; + int64_t consuming = 0; + + clock_gettime(CLOCK_REALTIME,&time1); + + std::string bundleName = "com.ohos.form.manager.performance"; + std::string abilityName = "FormAbilityPerformance"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // NotifyInvisibleForms + std::string eventData = FORM_EVENT_RECV_PERFORMANCE_TEST_0600; + SystemTestFormUtil::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0600, 600, eventData); + + // NotifyInvisibleForms Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_PERFORMANCE_TEST_0600, 600)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_PERFORMANCE_TEST_0600, 600); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + clock_gettime(CLOCK_REALTIME, &time2); + consuming = (time2.tv_sec * usecTimesA + time2.tv_nsec - (time1.tv_sec * usecTimesA + time1.tv_nsec)) / usecTimesB; + totalTime += consuming; + bool ret = FormPerformanceTest::SavePerformanceTestResult("FMS_performanceTest_0600", consuming); + std::cout << "SavePerformanceTestResult: "<< ret << "consuming:" << consuming << std::endl; + GTEST_LOG_(INFO) << "FMS_performanceTest_0600 NotifyInvisibleForms, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} + +void FormPerformanceTest::PerformanceTest_0700() +{ + struct timespec time1 = {0}; + struct timespec time2 = {0}; + int64_t usecTimesA = 1000000000; + int64_t usecTimesB = 1000000; + int64_t consuming = 0; + + clock_gettime(CLOCK_REALTIME,&time1); + + std::string bundleName = "com.ohos.form.manager.performance"; + std::string abilityName = "FormAbilityPerformance"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // RequestForm + std::string eventData = FORM_EVENT_RECV_PERFORMANCE_TEST_0700; + SystemTestFormUtil::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_0700, 700, eventData); + + // RequestForm Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_PERFORMANCE_TEST_0700, 700)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_PERFORMANCE_TEST_0700, 700); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + clock_gettime(CLOCK_REALTIME, &time2); + consuming = (time2.tv_sec * usecTimesA + time2.tv_nsec - (time1.tv_sec * usecTimesA + time1.tv_nsec)) / usecTimesB; + totalTime += consuming; + bool ret = FormPerformanceTest::SavePerformanceTestResult("FMS_performanceTest_0700", consuming); + std::cout << "SavePerformanceTestResult: "<< ret << "consuming:" << consuming << std::endl; + GTEST_LOG_(INFO) << "FMS_performanceTest_0700 RequestForm, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} + +void FormPerformanceTest::PerformanceTest_1300() +{ + struct timespec time1 = {0}; + struct timespec time2 = {0}; + int64_t usecTimesA = 1000000000; + int64_t usecTimesB = 1000000; + int64_t consuming = 0; + + clock_gettime(CLOCK_REALTIME,&time1); + + std::string bundleName = "com.ohos.form.manager.performance"; + std::string abilityName = "FormAbilityPerformance"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // GetAllFormsInfo + std::string eventData = FORM_EVENT_RECV_PERFORMANCE_TEST_1300; + SystemTestFormUtil::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_1300, 1300, eventData); + + // GetAllFormsInfo Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_PERFORMANCE_TEST_1300, 1300)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_PERFORMANCE_TEST_1300, 1300); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + clock_gettime(CLOCK_REALTIME, &time2); + consuming = (time2.tv_sec * usecTimesA + time2.tv_nsec - (time1.tv_sec * usecTimesA + time1.tv_nsec)) / usecTimesB; + totalTime += consuming; + bool ret = FormPerformanceTest::SavePerformanceTestResult("FMS_performanceTest_1300", consuming); + std::cout << "SavePerformanceTestResult: "<< ret << "consuming:" << consuming << std::endl; + GTEST_LOG_(INFO) << "FMS_performanceTest_1300 RequestForm, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} + +void FormPerformanceTest::PerformanceTest_1400() +{ + struct timespec time1 = {0}; + struct timespec time2 = {0}; + int64_t usecTimesA = 1000000000; + int64_t usecTimesB = 1000000; + int64_t consuming = 0; + + clock_gettime(CLOCK_REALTIME,&time1); + + std::string bundleName = "com.ohos.form.manager.performance"; + std::string abilityName = "FormAbilityPerformance"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // GetAllFormsInfo + std::string eventData = FORM_EVENT_RECV_PERFORMANCE_TEST_1300; + SystemTestFormUtil::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_1400, 1400, eventData); + + // GetAllFormsInfo Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_PERFORMANCE_TEST_1400, 1400)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_PERFORMANCE_TEST_1400, 1400); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + clock_gettime(CLOCK_REALTIME, &time2); + consuming = (time2.tv_sec * usecTimesA + time2.tv_nsec - (time1.tv_sec * usecTimesA + time1.tv_nsec)) / usecTimesB; + totalTime += consuming; + bool ret = FormPerformanceTest::SavePerformanceTestResult("FMS_performanceTest_1400", consuming); + std::cout << "SavePerformanceTestResult: "<< ret << "consuming:" << consuming << std::endl; + GTEST_LOG_(INFO) << "FMS_performanceTest_1400 RequestForm, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} + +void FormPerformanceTest::PerformanceTest_1500() +{ + struct timespec time1 = {0}; + struct timespec time2 = {0}; + int64_t usecTimesA = 1000000000; + int64_t usecTimesB = 1000000; + int64_t consuming = 0; + + clock_gettime(CLOCK_REALTIME,&time1); + + std::string bundleName = "com.ohos.form.manager.performance"; + std::string abilityName = "FormAbilityPerformance"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // GetAllFormsInfo + std::string eventData = FORM_EVENT_RECV_PERFORMANCE_TEST_1500; + SystemTestFormUtil::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_1500, 1500, eventData); + + // GetAllFormsInfo Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_PERFORMANCE_TEST_1500, 1500)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_PERFORMANCE_TEST_1500, 1500); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + clock_gettime(CLOCK_REALTIME, &time2); + consuming = (time2.tv_sec * usecTimesA + time2.tv_nsec - (time1.tv_sec * usecTimesA + time1.tv_nsec)) / usecTimesB; + totalTime += consuming; + bool ret = FormPerformanceTest::SavePerformanceTestResult("FMS_performanceTest_1500", consuming); + std::cout << "SavePerformanceTestResult: "<< ret << "consuming:" << consuming << std::endl; + GTEST_LOG_(INFO) << "FMS_performanceTest_1500 RequestForm, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} + +void FormPerformanceTest::PerformanceTest_1600() +{ + struct timespec time1 = {0}; + struct timespec time2 = {0}; + int64_t usecTimesA = 1000000000; + int64_t usecTimesB = 1000000; + int64_t consuming = 0; + + clock_gettime(CLOCK_REALTIME,&time1); + + std::string bundleName = "com.ohos.form.manager.performance"; + std::string abilityName = "FormAbilityPerformance"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // GetAllFormsInfo + std::string eventData = FORM_EVENT_RECV_PERFORMANCE_TEST_1600; + SystemTestFormUtil::PublishEvent(FORM_EVENT_RECV_PERFORMANCE_TEST_1600, 1600, eventData); + + // GetAllFormsInfo Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_PERFORMANCE_TEST_1600, 1600)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_PERFORMANCE_TEST_1600, 1600); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + clock_gettime(CLOCK_REALTIME, &time2); + consuming = (time2.tv_sec * usecTimesA + time2.tv_nsec - (time1.tv_sec * usecTimesA + time1.tv_nsec)) / usecTimesB; + totalTime += consuming; + bool ret = FormPerformanceTest::SavePerformanceTestResult("FMS_performanceTest_1600", consuming); + std::cout << "SavePerformanceTestResult: "<< ret << "consuming:" << consuming << std::endl; + GTEST_LOG_(INFO) << "FMS_performanceTest_1600 RequestForm, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} +/** + * @tc.number: FMS_performanceTest_0100 + * @tc.name: 创建卡片性能测试 + * @tc.desc: 测试创建卡片所需时间 + * + * 预置条件: + * 1.卡片使用方A有卡片使用权限 + * 2.卡片提供方A提供可创建卡片 + * 3.正确设置创建卡片接口参数 + * + * 测试步骤: + * 1.卡片使用方A调用创建卡片接口，创建卡片提供方A的卡片。 + * 2.创建卡片接口返回成功后，从log中获取创建卡片的开始时间和结束时间。 + * 3.通过创建卡片的开始时间和结束时间，计算创建卡片所需时间。 + * + * 预期结果: + * 创建卡片所需时间满足性能要求 + */ +HWTEST_F(FormPerformanceTest, FMS_performanceTest_0100, Function | MediumTest | Level3) +{ + std::cout << "START FMS_performanceTest_0100" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < pLevel_.executionTimesLevel; iExecutionTimes++) { + FormPerformanceTest::PerformanceTest_0100(); + std::cout << "FMS_performanceTest_0100 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_performanceTest_0100" << std::endl; +} + +/** + * @tc.number: FMS_performanceTest_0400 + * @tc.name: 临时卡片转常态卡片性能测试 + * @tc.desc: 测试临时卡片转常态卡片所需时间 + * + * 预置条件: + * 1.卡片使用方A有卡片使用权限 + * 2.卡片提供方A提供可创建卡片 + * 3.卡片使用方A创建卡片提供方A的1张临时卡片 + * 3.正确设置临时卡片转常态卡片接口参数 + * + * 测试步骤: + * 1.卡片使用方A调用临时卡片转常态卡片接口，把已创建的临时卡片转常态卡片。 + * 2.临时卡片转常态卡片接口返回成功后，从log中获取临时卡片转常态卡片的开始时间和结束时间。 + * 3.通过临时卡片转常态卡片的开始时间和结束时间，计算临时卡片转常态卡片所需时间。 + * + * 预期结果: + * 临时卡片转常态卡片所需时间满足性能要求。 + */ +HWTEST_F(FormPerformanceTest, FMS_performanceTest_0400, Function | MediumTest | Level3) +{ + std::cout << "START FMS_performanceTest_0400" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < pLevel_.executionTimesLevel; iExecutionTimes++) { + FormPerformanceTest::PerformanceTest_0400(); + std::cout << "FMS_performanceTest_0400 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_performanceTest_0400" << std::endl; +} + +/** + * @tc.number: FMS_performanceTest_0300 + * @tc.name: 释放卡片性能测试 + * @tc.desc: 测试释放卡片(指定是否释放缓存)所需时间 + * + * 预置条件: + * 1.卡片使用方A有卡片使用权限 + * 2.卡片提供方A提供可创建卡片 + * 3.卡片使用方A创建卡片提供方A的卡片 + * 4.正确设置释放卡片接口参数 + * + * 测试步骤: + * 1.卡片使用方A调用释放卡片(指定是否释放缓存)接口释放卡片。 + * 2.释放卡片接口返回成功后，从log中获取释放卡片的开始时间和结束时间。 + * 3.通过释放卡片的开始时间和结束时间，计算释放卡片所需时间。 + * + * 预期结果: + * 释放卡片(指定是否释放缓存)所需时间满足性能要求。 + */ +HWTEST_F(FormPerformanceTest, FMS_performanceTest_0300, Function | MediumTest | Level3) +{ + std::cout << "START FMS_performanceTest_0300" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < pLevel_.executionTimesLevel; iExecutionTimes++) { + FormPerformanceTest::PerformanceTest_0300(); + std::cout << "FMS_performanceTest_0300 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_performanceTest_0300" << std::endl; +} + +/** + * @tc.number: FMS_performanceTest_0200 + * @tc.name: 删除卡片性能测试 + * @tc.desc: 测试删除卡片所需时间 + * + * 预置条件: + * 1.卡片使用方A有卡片使用权限 + * 2.卡片提供方A提供可创建卡片 + * 3.卡片使用方A创建卡片提供方A的卡片 + * 4.正确设置删除卡片接口参数 + * + * 测试步骤: + * 1.卡片使用方A调用删除卡片接口删除卡片。 + * 2.删除卡片接口返回成功后，从log中获取删除卡片的开始时间和结束时间。 + * 3.通过删除卡片的开始时间和结束时间，计算删除卡片所需时间。 + * + * 预期结果: + * 删除卡片所需时间满足性能要求。 + */ +HWTEST_F(FormPerformanceTest, FMS_performanceTest_0200, Function | MediumTest | Level3) +{ + std::cout << "START FMS_performanceTest_0200" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < pLevel_.executionTimesLevel; iExecutionTimes++) { + FormPerformanceTest::PerformanceTest_0200(); + std::cout << "FMS_performanceTest_0200 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_performanceTest_0200" << std::endl; +} + +/** + * @tc.number: FMS_performanceTest_0500 + * @tc.name: 通知卡片可见性能测试 + * @tc.desc: 测试通知卡片可见所需时间 + * + * 预置条件: + * 1.卡片使用方A有卡片使用权限 + * 2.卡片提供方A提供可创建卡片 + * 3.卡片使用方A创建卡片提供方A的卡片 + * 4.正确设置通知卡片可见接口参数 + * + * 测试步骤: + * 1.卡片使用方A调用通知卡片可见接口设置卡片可见。 + * 2.通知卡片可见接口返回成功后，从log中获取通知卡片可见的开始时间和结束时间。 + * 3.通过通知卡片可见的开始时间和结束时间，计算通知卡片可见所需时间。 + * + * 预期结果: + * 通知卡片可见所需时间满足性能要求。 + */ +HWTEST_F(FormPerformanceTest, FMS_performanceTest_0500, Function | MediumTest | Level3) +{ + std::cout << "START FMS_performanceTest_0500" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < pLevel_.executionTimesLevel; iExecutionTimes++) { + FormPerformanceTest::PerformanceTest_0500(); + std::cout << "FMS_performanceTest_0500 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_performanceTest_0500" << std::endl; +} + +/** + * @tc.number: FMS_performanceTest_0600 + * @tc.name: 通知卡片不可见性能测试 + * @tc.desc: 测试通知卡片不可见所需时间 + * + * 预置条件: + * 1.卡片使用方A有卡片使用权限 + * 2.卡片提供方A提供可创建卡片 + * 3.卡片使用方A创建卡片提供方A的卡片 + * 4.正确设置通知卡片不可见接口参数 + * + * 测试步骤: + * 1.卡片使用方A调用通知卡片不可见接口设置卡片不可见。 + * 2.通知卡片不可见接口返回成功后，从log中获取通知卡片不可见的开始时间和结束时间。 + * 3.通过通知卡片不可见的开始时间和结束时间，计算通知卡片不可见所需时间。 + * + * 预期结果: + * 通知卡片可见所需时间满足性能要求。 + */ +HWTEST_F(FormPerformanceTest, FMS_performanceTest_0600, Function | MediumTest | Level3) +{ + std::cout << "START FMS_performanceTest_0600" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < pLevel_.executionTimesLevel; iExecutionTimes++) { + FormPerformanceTest::PerformanceTest_0600(); + std::cout << "FMS_performanceTest_0600 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_performanceTest_0600" << std::endl; +} + +/** + * @tc.number: FMS_performanceTest_0700 + * @tc.name: 卡片使用方主动刷新性能测试 + * @tc.desc: 测试卡片使用方主动刷新所需时间 + * + * 预置条件: + * 1.卡片使用方A有卡片使用权限 + * 2.卡片提供方A提供可创建卡片 + * 3.正确设置卡片使用方主动刷新接口参数 + * + * 测试步骤: + * 1.卡片使用方A调用卡片使用方主动刷新接口进行卡片刷新。 + * 2.卡片使用方主动刷新接口返回成功后，从log中获取卡片使用方主动刷新的开始时间和结束时间。 + * 3.通过卡片使用方主动刷新的开始时间和结束时间，计算卡片使用方主动刷新所需时间。 + * + * 预期结果: + * 卡片使用方主动刷新所需时间满足性能要求。 + */ +HWTEST_F(FormPerformanceTest, FMS_performanceTest_0700, Function | MediumTest | Level3) +{ + std::cout << "START FMS_performanceTest_0700" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < pLevel_.executionTimesLevel; iExecutionTimes++) { + FormPerformanceTest::PerformanceTest_0700(); + std::cout << "FMS_performanceTest_0700 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_performanceTest_0700" << std::endl; +} + +/** + * @tc.number: FMS_performanceTest_1300 + * @tc.name: 系统所有卡片配置信息查询性能测试 + * @tc.desc: 测试系统所有卡片配置信息查询所需时间 + * + * 预置条件: + * 1.卡片提供方A，B提供可创建卡片 + * 2.正确设置系统所有卡片配置信息查询接口参数 + * + * 测试步骤: + * 1.调用系统所有卡片配置信息查询接口。 + * 2.系统所有卡片配置信息查询接口返回成功后，从log中获取系统所有卡片配置信息查询的开始时间和结束时间。 + * 3.通过系统所有卡片配置信息查询的开始时间和结束时间，计算系统所有卡片配置信息查询所需时间。 + * + * 预期结果: + * 系统所有卡片配置信息查询所需时间满足性能要求。 + */ +HWTEST_F(FormPerformanceTest, FMS_performanceTest_1300, Function | MediumTest | Level3) +{ + std::cout << "START FMS_performanceTest_1300" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < pLevel_.executionTimesLevel; iExecutionTimes++) { + FormPerformanceTest::PerformanceTest_1300(); + std::cout << "FMS_performanceTest_1300 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_performanceTest_1300" << std::endl; +} + +/** + * @tc.number: FMS_performanceTest_1400 + * @tc.name: 指定包的卡片配置信息查询性能测试 + * @tc.desc: 测试指定包的卡片配置信息查询所需时间 + * + * 预置条件: + * 1.卡片提供方A，B提供可创建卡片 + * 2.正确设置指定包的卡片配置信息查询接口参数 + * + * 测试步骤: + * 1.调用指定包的卡片配置信息查询接口。 + * 2.指定包的卡片配置信息查询接口返回成功后，从log中获取指定包的卡片配置信息查询的开始时间和结束时间。 + * 3.通过指定包的卡片配置信息查询的开始时间和结束时间，计算指定包的卡片配置信息查询所需时间。 + * + * 预期结果: + * 指定包的卡片配置信息查询所需时间满足性能要求。 + */ +HWTEST_F(FormPerformanceTest, FMS_performanceTest_1400, Function | MediumTest | Level3) +{ + std::cout << "START FMS_performanceTest_1400" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < pLevel_.executionTimesLevel; iExecutionTimes++) { + FormPerformanceTest::PerformanceTest_1400(); + std::cout << "FMS_performanceTest_1400 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_performanceTest_1400" << std::endl; +} + +/** + * @tc.number: FMS_performanceTest_1500 + * @tc.name: 指定模块的卡片配置信息查询性能测试 + * @tc.desc: 测试指定模块的卡片配置信息查询所需时间 + * + * 预置条件: + * 1.卡片提供方A，B提供可创建卡片 + * 2.正确设置系统所有卡片配置信息查询接口参数 + * + * 测试步骤: + * 1.调用指定模块的卡片配置信息查询接口。 + * 2.指定模块的卡片配置信息查询接口返回成功后，从log中获取指定模块的卡片配置信息查询的开始时间和结束时间。 + * 3.通过指定模块的卡片配置信息查询的开始时间和结束时间，计算指定模块的卡片配置信息查询所需时间。 + * + * 预期结果: + * 指定模块的卡片配置信息查询所需时间满足性能要求。 + */ +HWTEST_F(FormPerformanceTest, FMS_performanceTest_1500, Function | MediumTest | Level3) +{ + std::cout << "START FMS_performanceTest_1500" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < pLevel_.executionTimesLevel; iExecutionTimes++) { + FormPerformanceTest::PerformanceTest_1500(); + std::cout << "FMS_performanceTest_1500 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_performanceTest_1500" << std::endl; +} + +/** + * @tc.number: FMS_performanceTest_1600 + * @tc.name: FMS状态检查性能测试 + * @tc.desc: 测试FMS状态检查所需时间 + * + * 预置条件: + * 1.卡片使用方A有卡片使用权限 + * 2.卡片提供方A提供可创建卡片 + * 3.卡片使用方A创建卡片提供方A的卡片 + * 4.正确设置卡片事件管理接口参数 + * + * 测试步骤: + * 1.卡片提供方A调用卡片事件管理接口。 + * 2.卡片事件管理接口返回成功后，从log中获取卡片事件管理的开始时间和结束时间。 + * 3.通过卡片事件管理的开始时间和结束时间，计算卡片事件管理所需时间。 + * + * 预期结果: + * FMS状态检查所需时间满足性能要求。 + */ +HWTEST_F(FormPerformanceTest, FMS_performanceTest_1600, Function | MediumTest | Level3) +{ + std::cout << "START FMS_performanceTest_1600" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < pLevel_.executionTimesLevel; iExecutionTimes++) { + FormPerformanceTest::PerformanceTest_1600(); + std::cout << "FMS_performanceTest_1600 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_performanceTest_1600" << std::endl; +} + +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/systemtest/common/fms/fms_performance_test/performance_config_parser.h b/test/systemtest/common/fms/fms_performance_test/performance_config_parser.h new file mode 100644 index 0000000000..2c8b9b5525 --- /dev/null +++ b/test/systemtest/common/fms/fms_performance_test/performance_config_parser.h @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef PERFORMANCE_CONFIG_PARSER_H +#define PERFORMANCE_CONFIG_PARSER_H + +#include +#include +#include + +#include "nlohmann/json.hpp" + +namespace OHOS { +namespace AppExecFwk { + +const std::string PERFORMANCE_CONFIG_FILE_PATH{"./fms_performance_config.json"}; + +const std::string PERFORMANCE_EXECUTION_TIMES_KEY{"ExecutionTimes"}; + +struct PerformanceLevel { + int32_t executionTimesLevel{1}; +}; + +class PerformanceConfigParser { +public: + void ParseForPerformance(const std::string &path, PerformanceLevel &stlevel) + { + std::ifstream jf(path); + if (!jf.is_open()) { + std::cout << "json file can not open!" << std::endl; + return; + } + nlohmann::json jsonObj; + jf >> jsonObj; + const auto &jsonObjEnd = jsonObj.end(); + if (jsonObj.find(PERFORMANCE_EXECUTION_TIMES_KEY) != jsonObjEnd) { + jsonObj.at(PERFORMANCE_EXECUTION_TIMES_KEY).get_to(stlevel.executionTimesLevel); + if (0 == stlevel.executionTimesLevel) { + stlevel.executionTimesLevel = 1; + } + } + } +}; + +} // namespace AppExecFwk +} // namespace OHOS + +#endif // PERFORMANCE_CONFIG_PARSER_H diff --git a/test/systemtest/common/fms/fms_release_form_test/BUILD.gn b/test/systemtest/common/fms/fms_release_form_test/BUILD.gn new file mode 100644 index 0000000000..f44fd8be31 --- /dev/null +++ b/test/systemtest/common/fms/fms_release_form_test/BUILD.gn @@ -0,0 +1,75 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/appexecfwk/standard/appexecfwk.gni") + +module_output_path = "appexecfwk_standard/formmanagerst" + +ohos_systemtest("FormReleaseFormTest") { + module_out_path = module_output_path + include_dirs = [ + "${aafwk_path}/interfaces/innerkits/ability_manager/include", + "${appexecfwk_path}/test/systemtest/common/fms/common/include", + "//base/notification/ces_standard/test/systemtest/common/resource", + "//foundation/distributedschedule/safwk/services/safwk/include", + ] + + sources = [ + "${appexecfwk_path}/test/systemtest/common/fms/common/src/form_event.cpp", + "${appexecfwk_path}/test/systemtest/common/fms/common/src/form_st_dump_util.cpp", + "${appexecfwk_path}/test/systemtest/common/fms/common/src/form_st_operator.cpp", + "${appexecfwk_path}/test/systemtest/common/fms/common/src/form_st_util.cpp", + "fms_release_form_test.cpp", + ] + + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + + configs = [ + "${aafwk_path}/services/abilitymgr:abilityms_config", + "${appexecfwk_path}/services/appmgr:appmgr_config", + ] + + deps = [ + "${aafwk_path}/frameworks/kits/ability/native:abilitykit_native", + "${aafwk_path}/services/abilitymgr:abilityms", + "${appexecfwk_path}/common:libappexecfwk_common", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//third_party/googletest:gtest_main", + ] + + defines = [ "APP_LOG_TAG = \"FMSReleaseFormTest\"" ] + + external_deps = [ + "aafwk_standard:base", + "aafwk_standard:want", + "appexecfwk_standard:appexecfwk_base", + "appexecfwk_standard:appexecfwk_core", + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr_L2:samgr_proxy", + ] +} + +group("systemtest") { + testonly = true + + deps = [ ":FormReleaseFormTest" ] +} diff --git a/test/systemtest/common/fms/fms_release_form_test/fms_release_form_test.cpp b/test/systemtest/common/fms/fms_release_form_test/fms_release_form_test.cpp new file mode 100644 index 0000000000..cc090c18ee --- /dev/null +++ b/test/systemtest/common/fms/fms_release_form_test/fms_release_form_test.cpp @@ -0,0 +1,861 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include "app_log_wrapper.h" +#include "ability_info.h" +#include "ability_handler.h" +#include "ability_local_record.h" +#include "ability_start_setting.h" +#include "common_event.h" +#include "common_event_manager.h" +#include "context_deal.h" +#include "form_event.h" +#include "form_st_common_info.h" +#include "form_st_util.h" +#include "iservice_registry.h" +#include "nlohmann/json.hpp" +#include "system_ability_definition.h" + +using OHOS::AAFwk::Want; +using namespace testing::ext; +using namespace std::chrono_literals; +using namespace OHOS::STtools; + +namespace { +std::vector bundleNameList = { + "com.ohos.form.manager.notsystemapp", + "com.ohos.form.manager.nopermission", + "com.ohos.form.manager.normal", + "com.ohos.form.manager.commona" +}; +std::vector hapNameList = { + "fmsSystemTestHostNotSys-signed", + "fmsSystemTestHostNoPerm-signed", + "fmsSystemTestHostNormal-signed", + "fmsSystemTestHostCommonA-signed" +}; +} // namespace + +namespace OHOS { +namespace AppExecFwk { +class FormReleaseFormTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + + static bool SubscribeEvent(); + + void SetUp(); + void TearDown(); + + void StartAbilityKitTest(const std::string &abilityName, const std::string &bundleName); + void TerminateAbility(const std::string &eventName, const std::string &abilityName); + + class FormEventSubscriber : public CommonEventSubscriber { + public: + explicit FormEventSubscriber(const CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp){}; + virtual void OnReceiveEvent(const CommonEventData &data) override; + ~FormEventSubscriber() = default; + }; + + static sptr abilityMs; + static FormEvent event; + // static FormEvent formEvent; + static std::vector eventList; + static std::shared_ptr subscriber_; +}; + +std::vector FormReleaseFormTest::eventList = { + FORM_EVENT_ABILITY_ONACTIVED, + FORM_EVENT_RECV_RELEASE_FORM_0100, + FORM_EVENT_RECV_RELEASE_FORM_0200, + FORM_EVENT_RECV_RELEASE_FORM_0300, + FORM_EVENT_RECV_RELEASE_FORM_0400, + FORM_EVENT_RECV_RELEASE_FORM_0500, + FORM_EVENT_RECV_RELEASE_FORM_0600, + FORM_EVENT_RECV_RELEASE_FORM_0700, + FORM_EVENT_RECV_RELEASE_FORM_0800, + FORM_EVENT_RECV_RELEASE_FORM_0900, + FORM_EVENT_RECV_RELEASE_FORM_1000, + FORM_EVENT_RECV_RELEASE_FORM_1100, + FORM_EVENT_RECV_RELEASE_FORM_1200, + FORM_EVENT_RECV_RELEASE_FORM_1300, + FORM_EVENT_RECV_RELEASE_FORM_1400, + FORM_EVENT_RECV_ONE_NORMAL_FORM, +}; + +static std::string form_id = ""; +FormEvent FormReleaseFormTest::event = FormEvent(); +// FormEvent FormReleaseFormTest::formEvent = FormEvent(); +sptr FormReleaseFormTest::abilityMs = nullptr; +std::shared_ptr FormReleaseFormTest::subscriber_ = nullptr; +void FormReleaseFormTest::FormEventSubscriber::OnReceiveEvent(const CommonEventData &data) +{ + GTEST_LOG_(INFO) << "OnReceiveEvent: event=" << data.GetWant().GetAction(); + GTEST_LOG_(INFO) << "OnReceiveEvent: data=" << data.GetData(); + GTEST_LOG_(INFO) << "OnReceiveEvent: code=" << data.GetCode(); + + if (data.GetCode() == 110) { + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ONE_NORMAL_FORM, 110, data.GetData()); + } + SystemTestFormUtil::Completed(event, data.GetWant().GetAction(), data.GetCode(), data.GetData()); +} + +void FormReleaseFormTest::SetUpTestCase() +{ + std::cout << "START Install============" << std::endl; + SystemTestFormUtil::InstallHaps(hapNameList); + if (!SubscribeEvent()) { + GTEST_LOG_(INFO) << "SubscribeEvent error"; + } +} + +void FormReleaseFormTest::TearDownTestCase() +{ + std::cout << "START Uninstall============" << std::endl; + SystemTestFormUtil::UninstallBundle(bundleNameList); + CommonEventManager::UnSubscribeCommonEvent(subscriber_); +} + +void FormReleaseFormTest::SetUp() +{ +} + +void FormReleaseFormTest::TearDown() +{ + SystemTestFormUtil::CleanMsg(event); + // SystemTestFormUtil::CleanMsg(formEvent); +} +bool FormReleaseFormTest::SubscribeEvent() +{ + std::vector eventList = { + FORM_EVENT_ABILITY_ONACTIVED, + FORM_EVENT_RECV_RELEASE_FORM_0100, + FORM_EVENT_RECV_RELEASE_FORM_0200, + FORM_EVENT_RECV_RELEASE_FORM_0300, + FORM_EVENT_RECV_RELEASE_FORM_0400, + FORM_EVENT_RECV_RELEASE_FORM_0500, + FORM_EVENT_RECV_RELEASE_FORM_0600, + FORM_EVENT_RECV_RELEASE_FORM_0700, + FORM_EVENT_RECV_RELEASE_FORM_0800, + FORM_EVENT_RECV_RELEASE_FORM_0900, + FORM_EVENT_RECV_RELEASE_FORM_1000, + FORM_EVENT_RECV_RELEASE_FORM_1100, + FORM_EVENT_RECV_RELEASE_FORM_1200, + FORM_EVENT_RECV_RELEASE_FORM_1300, + FORM_EVENT_RECV_RELEASE_FORM_1400, + FORM_EVENT_RECV_ONE_NORMAL_FORM, + }; + MatchingSkills matchingSkills; + for (const auto &e : eventList) { + matchingSkills.AddEvent(e); + } + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + subscribeInfo.SetPriority(1); + subscriber_ = std::make_shared(subscribeInfo); + return CommonEventManager::SubscribeCommonEvent(subscriber_); +} + +/** + * @tc.number: FMS_releaseForm_0100 + * @tc.name: 卡片使用方不是系统应用时调用释放卡片接口 + * @tc.desc: + * 预置条件: + * 1.卡片使用方不是系统应用 + * 2.设置下面释放卡片参数： + * ·formId：1 + * ·isReleaseCache：true + * 测试步骤: + * 1.调用释放卡片接口。 + * 2.验证释放卡片返回结果。 + * 预期结果: 释放卡片接口返回失败。（错误原因：卡片使用方不是系统应用。） + */ +HWTEST_F(FormReleaseFormTest, FMS_releaseForm_0100, Function | MediumTest | Level0) +{ + std::cout << "============START FMS_releaseForm_0100" << std::endl; + + std::string bundleName = "com.ohos.form.manager.notsystemapp"; + std::string abilityName = "FormAbilityNotSys"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_RELEASE_FORM_0100; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_RELEASE_FORM_0100, 100, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_RELEASE_FORM_0100, 100)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_RELEASE_FORM_0100, 100); + bool result = data == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_releaseForm_0100, result:" << result; + } + + std::cout << "============END FMS_releaseForm_0100" << std::endl; +} + +/** + * @tc.number: FMS_releaseForm_0200 + * @tc.name: 卡片使用方没有卡片使用权限时调用释放卡片接口 + * @tc.desc: + * 预置条件: + * 1.卡片使用方没有卡片使用权限 + * 2.存在已创建的卡片 + * 3.设置下面释放卡片参数： + * ·formId：已创建的卡片ID + * ·isReleaseCache：true + * 测试步骤: + * 1.调用释放卡片接口。 + * 2.验证释放卡片返回结果。 + * 预期结果: 释放卡片接口返回失败。（错误原因：卡片使用方没有卡片权限。） + */ +HWTEST_F(FormReleaseFormTest, FMS_releaseForm_0200, Function | MediumTest | Level0) +{ + std::cout << "============START FMS_releaseForm_0200" << std::endl; + + std::string bundleName = "com.ohos.form.manager.nopermission"; + std::string abilityName = "FormAbilityNoPerm"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_RELEASE_FORM_0200; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_RELEASE_FORM_0200, 200, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_RELEASE_FORM_0200, 200)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_RELEASE_FORM_0200, 200); + bool result = data == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_releaseForm_0200, result:" << result; + } + + std::cout << "============END FMS_releaseForm_0200" << std::endl; +} + +/** + * @tc.number: FMS_releaseForm_0300 + * @tc.name: 释放卡片接口中，卡片ID错误（formId < 0） + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.存在已经创建的卡片 + * 3.设置下面释放卡片参数： + * ·formId：-1 + * ·isReleaseCache：true + * 测试步骤: + * 1.调用释放卡片接口。 + * 2.验证释放卡片返回结果。 + * 预期结果: 释放卡片接口返回失败。（错误原因：卡片ID错误） + */ +HWTEST_F(FormReleaseFormTest, FMS_releaseForm_0300, Function | MediumTest | Level0) +{ + std::cout << "============START FMS_releaseForm_0300" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityReleaseForm"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_RELEASE_FORM_0300; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_RELEASE_FORM_0300, 300, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_RELEASE_FORM_0300, 300)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_RELEASE_FORM_0300, 300); + bool result = data == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_releaseForm_0300, result:" << result; + } + SystemTestFormUtil::CleanMsg(event); + std::cout << "============END FMS_releaseForm_0300" << std::endl; +} + +/** + * @tc.number: FMS_releaseForm_0400 + * @tc.name: 释放卡片接口中，卡片ID错误（formId = 0） + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.存在已经创建的卡片 + * 3.设置下面释放卡片参数： + * ·formId：0 + * ·isReleaseCache：true + * 测试步骤: + * 1.调用释放卡片接口。 + * 2.验证释放卡片返回结果。 + * 预期结果: 释放卡片接口返回失败。（错误原因：卡片ID错误） + */ +HWTEST_F(FormReleaseFormTest, FMS_releaseForm_0400, Function | MediumTest | Level0) +{ + std::cout << "============START FMS_releaseForm_0400" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityReleaseForm"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_RELEASE_FORM_0400; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_RELEASE_FORM_0400, 400, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_RELEASE_FORM_0400, 400)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_RELEASE_FORM_0400, 400); + bool result = data == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_releaseForm_0400, result:" << result; + } + SystemTestFormUtil::CleanMsg(event); + std::cout << "============END FMS_releaseForm_0400" << std::endl; +} + +/** + * @tc.number: FMS_releaseForm_0500 + * @tc.name: 释放卡片接口中，卡片ID错误（formId非所属） + * @tc.desc: + * 预置条件: + * 1.卡片使用方A，B有卡片使用权限 + * 2.卡片使用方A创建1张卡片 + * 3.设置下面释放卡片参数： + * ·formId：2创建的卡片ID + * ·isReleaseCache：true + * 测试步骤: + * 1.卡片使用方B调用释放卡片接口。 + * 2.验证释放卡片返回结果。 + * 预期结果: 释放卡片接口返回失败。。（错误原因：卡片ID错误） + */ +HWTEST_F(FormReleaseFormTest, FMS_releaseForm_0500, Function | MediumTest | Level0) +{ + std::cout << "============START FMS_releaseForm_0500" << std::endl; + std::string bundleName = "com.ohos.form.manager.commona"; + std::string abilityName = "FormAbilityCommonA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = "false"; //normal form + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ONE_NORMAL_FORM, 100, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100); + + GTEST_LOG_(INFO) << "FMS_releaseForm_0500, data:[" << data << "]" << std::endl; + if (data != "") { + std::string bundleName2 = "com.ohos.form.manager.normal"; + std::string abilityName2 = "FormAbilityReleaseForm"; + MAP_STR_STR params2; + Want want2 = SystemTestFormUtil::MakeWant("device", abilityName2, bundleName2, params2); + SystemTestFormUtil::StartAbility(want2, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData2 = data; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_RELEASE_FORM_0500, 500, eventData2); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_RELEASE_FORM_0500, 500)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_RELEASE_FORM_0500, 500); + bool result = data2 == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_releaseForm_0500, result:" << result; + } + } + SystemTestFormUtil::CleanMsg(event); + std::cout << "============END FMS_releaseForm_0500" << std::endl; +} + +/** + * @tc.number: FMS_releaseForm_0600 + * @tc.name: 释放卡片接口中，卡片ID错误（formId不存在） + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.卡片使用方创建1张卡片 + * 3.卡片使用方删除已创建卡片 + * 4.设置下面释放卡片参数： + * ·formId：3删除的卡片ID + * ·isReleaseCache：true + * 测试步骤: + * 1.调用释放卡片接口。 + * 2.验证释放卡片返回结果。 + * 预期结果: + * 1.释放卡片接口返回失败。（错误原因：卡片ID不存在） + */ +HWTEST_F(FormReleaseFormTest, FMS_releaseForm_0600, Function | MediumTest | Level0) +{ + std::cout << "============START FMS_releaseForm_0600" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityReleaseForm"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_RELEASE_FORM_0600; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_RELEASE_FORM_0600, 600, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_RELEASE_FORM_0600, 600)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_RELEASE_FORM_0600, 600); + bool result = data == "false"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_releaseForm_0600, result:" << result; + } + SystemTestFormUtil::CleanMsg(event); + + std::cout << "============END FMS_releaseForm_0600" << std::endl; +} + +/** + * @tc.number: FMS_releaseForm_0700 + * @tc.name: 释放卡片接口（删除卡片缓存标识为false）释放卡片后卡片引用不为0 + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.卡片使用方A，B分别创建1张相同卡片ID的卡片 + * 3.设置下面释放卡片参数： + * ·formId：已创建所属的卡片ID + * ·isReleaseCache：false + * 测试步骤: + * 1.卡片使用方A调用释放卡片接口。 + * 2.验证卡片宿主对象是否被删除。 + * 3.验证缓存信息是否被删除。 + * 4.验证卡片持久化数据是否被删除。 + * 5.验证释放卡片接口返回结果。 + * 预期结果: + * 1.卡片宿主对象被删除。 + * 2.缓存信息没有被删除。 + * 3.卡片持久化数据没有被删除。 + * 4.释放卡片接口返回成功。 + */ +HWTEST_F(FormReleaseFormTest, FMS_releaseForm_0700, Function | MediumTest | Level1) +{ + std::cout << "============START FMS_releaseForm_0700" << std::endl; + + std::string bundleName = "com.ohos.form.manager.commona"; + std::string abilityName = "FormAbilityCommonA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = "false"; //normal form + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ONE_NORMAL_FORM, 100, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100); + + GTEST_LOG_(INFO) << "FMS_releaseForm_0700, data:[" << data << "]" << std::endl; + if (data != "") { + std::string bundleName2 = "com.ohos.form.manager.normal"; + std::string abilityName2 = "FormAbilityReleaseForm"; + MAP_STR_STR params2; + Want want2 = SystemTestFormUtil::MakeWant("device", abilityName2, bundleName2, params2); + SystemTestFormUtil::StartAbility(want2, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData2 = data; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_RELEASE_FORM_0700, 700, eventData2); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_RELEASE_FORM_0700, 700)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_RELEASE_FORM_0700, 700); + bool result = data2 == "true"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_releaseForm_0700, result:" << result; + } + } + SystemTestFormUtil::CleanMsg(event); + + std::cout << "============END FMS_releaseForm_0700" << std::endl; +} + +/** + * @tc.number: FMS_releaseForm_0800 + * @tc.name: 释放卡片接口（删除卡片缓存标识为false）释放卡片后卡片引用为0且FMS中还有其他常态卡片 + * @tc.desc: + * 预置条件: + * 1.卡片使用方A，B有卡片使用权限 + * 2.卡片使用方A，B各创建1张卡片 + * 3.设置下面释放卡片参数： + * ·formId：卡片使用方A已创建的卡片ID + * ·isReleaseCache：false + * 测试步骤: + * 1.卡片使用方A调用释放卡片接口。 + * 2.验证卡片定时任务是否被停止。。 + * 3.验证缓存信息是否被删除。 + * 4.验证卡片持久化数据是否被删除。 + * 5.验证释放卡片接口返回结果。 + * 预期结果: + * 1.停止卡片定时任务。 + * 2.缓存信息没有被删除。 + * 3.卡片持久化数据没有被删除。 + * 4.释放卡片接口返回成功。 + */ +HWTEST_F(FormReleaseFormTest, FMS_releaseForm_0800, Function | MediumTest | Level1) +{ + std::cout << "============START FMS_releaseForm_0800" << std::endl; + + std::string bundleName = "com.ohos.form.manager.commona"; + std::string abilityName = "FormAbilityCommonA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = "false"; //normal form + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ONE_NORMAL_FORM, 100, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100); + + GTEST_LOG_(INFO) << "FMS_releaseForm_0800, data:[" << data << "]" << std::endl; + if (data != "") { + std::string bundleName2 = "com.ohos.form.manager.normal"; + std::string abilityName2 = "FormAbilityReleaseForm"; + MAP_STR_STR params2; + Want want2 = SystemTestFormUtil::MakeWant("device", abilityName2, bundleName2, params2); + SystemTestFormUtil::StartAbility(want2, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData2 = data; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_RELEASE_FORM_0800, 800, eventData2); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_RELEASE_FORM_0800, 800)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_RELEASE_FORM_0800, 800); + bool result = data2 == "true"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_releaseForm_0800, result:" << result; + } + } + SystemTestFormUtil::CleanMsg(event); + std::cout << "============END FMS_releaseForm_0800" << std::endl; +} + +/** + * @tc.number: FMS_releaseForm_0900 + * @tc.name: 释放卡片接口（删除卡片缓存标识为false）释放卡片后FMS中没有其他常态卡片 + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.卡片使用方创建1张常态卡片 + * 3.设置下面释放卡片参数： + * ·formId：2中已创建的卡片ID + * ·isReleaseCache：false + * 测试步骤: + * 1.卡片使用方调用释放卡片接口。 + * 2.验证卡片宿主对象是否被删除。 + * 3.验证定时器是否被销毁。 + * 4.验证缓存信息是否被删除。 + * 5.验证卡片持久化数据是否被删除。 + * 6.验证释放卡片接口返回结果。 + * 预期结果: + * 1.卡片宿主对象被删除。 + * 2.定时器被销毁 + * 3.缓存信息没有被删除。 + * 4.卡片持久化数据没有被删除。 + * 5.释放卡片接口返回成功。 + */ +HWTEST_F(FormReleaseFormTest, FMS_releaseForm_0900, Function | MediumTest | Level1) +{ + std::cout << "============START FMS_releaseForm_0900" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityReleaseForm"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_RELEASE_FORM_0900; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_RELEASE_FORM_0900, 900, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_RELEASE_FORM_0900, 900)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_RELEASE_FORM_0900, 900); + bool result = data == "true"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_releaseForm_0900, result:" << result; + } + SystemTestFormUtil::CleanMsg(event); + + std::cout << "============END FMS_releaseForm_0900" << std::endl; +} + +/** + * @tc.number: FMS_releaseForm_1000 + * @tc.name: 释放卡片接口（删除卡片缓存标识为true）释放卡片后卡片引用不为0 + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.卡片使用方A，B分别创建1张相同卡片ID的卡片 + * 3.设置下面释放卡片参数： + * ·formId：已创建所属的卡片ID + * ·isReleaseCache：true + * 测试步骤: + * 1.卡片使用方A调用释放卡片接口。 + * 2.验证卡片宿主对象是否被删除。 + * 3.验证缓存信息是否被删除。 + * 4.验证卡片持久化数据是否被删除。 + * 5.验证释放卡片接口返回结果。 + * 预期结果: + * 1.卡片宿主对象被删除。 + * 2.缓存信息被删除。 + * 3.卡片持久化数据没有被删除。 + * 4.释放卡片接口返回成功。 + */ +HWTEST_F(FormReleaseFormTest, FMS_releaseForm_1000, Function | MediumTest | Level1) +{ + std::cout << "============START FMS_releaseForm_1000" << std::endl; + + std::string bundleName = "com.ohos.form.manager.commona"; + std::string abilityName = "FormAbilityCommonA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = "false"; //normal form + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ONE_NORMAL_FORM, 100, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100); + + GTEST_LOG_(INFO) << "FMS_releaseForm_1000, data:[" << data << "]" << std::endl; + if (data != "") { + std::string bundleName2 = "com.ohos.form.manager.normal"; + std::string abilityName2 = "FormAbilityReleaseForm"; + MAP_STR_STR params2; + Want want2 = SystemTestFormUtil::MakeWant("device", abilityName2, bundleName2, params2); + SystemTestFormUtil::StartAbility(want2, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData2 = data; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_RELEASE_FORM_1000, 1000, eventData2); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_RELEASE_FORM_1000, 1000)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_RELEASE_FORM_1000, 1000); + bool result = data2 == "true"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_releaseForm_1000, result:" << result; + } + } + SystemTestFormUtil::CleanMsg(event); + + std::cout << "============END FMS_releaseForm_1000" << std::endl; +} + +/** + * @tc.number: FMS_releaseForm_1100 + * @tc.name: 释放卡片接口（删除卡片缓存标识为true）释放卡片后卡片引用为0且FMS中还有其他常态卡片 + * @tc.desc: + * 预置条件: + * 1.卡片使用方A，B有卡片使用权限 + * 2.卡片使用方A，B各创建1张卡片 + * 3.设置下面释放卡片参数： + * ·formId：卡片使用方A已创建的卡片ID + * ·isReleaseCache：true + * 测试步骤: + * 1.卡片使用方A调用释放卡片接口。 + * 2.验证卡片定时任务是否被停止。。 + * 3.验证缓存信息是否被删除。 + * 4.验证卡片持久化数据是否被删除。 + * 5.验证释放卡片接口返回结果。 + * 预期结果: + * 1.停止卡片定时任务。 + * 2.缓存信息被删除。 + * 3.卡片持久化数据没有被删除。 + * 4.释放卡片接口返回成功。 + */ +HWTEST_F(FormReleaseFormTest, FMS_releaseForm_1100, Function | MediumTest | Level1) +{ + std::cout << "============START FMS_releaseForm_1100" << std::endl; + + std::string bundleName = "com.ohos.form.manager.commona"; + std::string abilityName = "FormAbilityCommonA"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = "false"; //normal form + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_ONE_NORMAL_FORM, 100, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_ONE_NORMAL_FORM, 100); + + GTEST_LOG_(INFO) << "FMS_releaseForm_1100, data:[" << data << "]" << std::endl; + if (data != "") { + std::string bundleName2 = "com.ohos.form.manager.normal"; + std::string abilityName2 = "FormAbilityReleaseForm"; + MAP_STR_STR params2; + Want want2 = SystemTestFormUtil::MakeWant("device", abilityName2, bundleName2, params2); + SystemTestFormUtil::StartAbility(want2, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData2 = data; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_RELEASE_FORM_1100, 1100, eventData2); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_RELEASE_FORM_1100, 1100)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_RELEASE_FORM_1100, 1100); + bool result = data2 == "true"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_releaseForm_1100, result:" << result; + } + } + SystemTestFormUtil::CleanMsg(event); + + std::cout << "============END FMS_releaseForm_1100" << std::endl; +} + +/** + * @tc.number: FMS_releaseForm_1200 + * @tc.name: 释放卡片接口（删除卡片缓存标识为true）释放卡片后FMS中没有其他常态卡片 + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.卡片使用方创建1张常态卡片 + * 3.设置下面释放卡片参数： + * ·formId：2中已创建的卡片ID + * ·isReleaseCache：true + * 测试步骤: + * 1.卡片使用方调用释放卡片接口。 + * 2.验证卡片宿主对象是否被删除。 + * 3.验证定时器是否被销毁。 + * 4.验证缓存信息是否被删除。 + * 5.验证卡片持久化数据是否被删除。 + * 6.验证释放卡片接口返回结果。 + * 预期结果: + * 1.卡片宿主对象被删除。 + * 2.定时器被销毁 + * 3.缓存信息被删除。 + * 4.卡片持久化数据没有被删除。 + * 5.释放卡片接口返回成功。 + */ +HWTEST_F(FormReleaseFormTest, FMS_releaseForm_1200, Function | MediumTest | Level1) +{ + std::cout << "============START FMS_releaseForm_1200" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityReleaseForm"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_RELEASE_FORM_1200; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_RELEASE_FORM_1200, 1200, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_RELEASE_FORM_1200, 1200)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_RELEASE_FORM_1200, 1200); + bool result = data == "true"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_releaseForm_1200, result:" << result; + } + SystemTestFormUtil::CleanMsg(event); + + std::cout << "============END FMS_releaseForm_1200" << std::endl; +} + +/** + * @tc.number: FMS_releaseForm_1300 + * @tc.name: 单使用方使用释放卡片接口连续释放卡片 + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.存在2张单使用方已创建的不同卡片 + * 测试步骤: + * 1.单使用方连续调用释放卡片接口释放卡片。 + * 2.验证全部释放卡片接口返回结果。 + * 预期结果: 释放卡片接口返回成功。 + */ +HWTEST_F(FormReleaseFormTest, FMS_releaseForm_1300, Function | MediumTest | Level2) +{ + std::cout << "============START FMS_releaseForm_1300" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityReleaseForm"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = ""; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_RELEASE_FORM_1300, 1300, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_RELEASE_FORM_1300, 1300)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_RELEASE_FORM_1300, 1300); + bool result = data != ""; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_releaseForm_1300, result:" << result; + } + GTEST_LOG_(INFO) << "FMS_releaseForm_1300, data:[" << data << "]" << std::endl; + if (data != "") { + std::string eventData2 = data; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_RELEASE_FORM_1300, 1300, eventData2); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_RELEASE_FORM_1300, 1300)); + std::string data2 = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_RELEASE_FORM_1300, 1300); + bool result2 = data2 == "true"; + EXPECT_TRUE(result2); + if (!result2) { + GTEST_LOG_(INFO) << "FMS_releaseForm_1300, result2:" << result2; + } + } + SystemTestFormUtil::CleanMsg(event); + + std::cout << "============END FMS_releaseForm_1300" << std::endl; +} + +/** + * @tc.number: FMS_releaseForm_1400 + * @tc.name: 释放卡片接口释放临时卡片 + * @tc.desc: + * 预置条件: + * 1.卡片使用方有卡片使用权限 + * 2.存在卡片使用方已经创建的临时卡片 + * 3.设置下面释放卡片参数： + * ·formId：临时卡片ID + * ·isReleaseCache：true + * 测试步骤: + * 1.调用释放卡片接口。 + * 2.验证释放卡片返回结果。 + * 预期结果: 释放卡片接口返回成功。 + */ +HWTEST_F(FormReleaseFormTest, FMS_releaseForm_1400, Function | MediumTest | Level1) +{ + std::cout << "============START FMS_releaseForm_1400" << std::endl; + + std::string bundleName = "com.ohos.form.manager.normal"; + std::string abilityName = "FormAbilityReleaseForm"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + std::string eventData = FORM_EVENT_REQ_RELEASE_FORM_1400; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_RELEASE_FORM_1400, 1400, eventData); + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_RELEASE_FORM_1400, 1400)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_RELEASE_FORM_1400, 1400); + bool result = data == "true"; + EXPECT_TRUE(result); + if (!result) { + GTEST_LOG_(INFO) << "FMS_releaseForm_1400, result:" << result; + } + SystemTestFormUtil::CleanMsg(event); + + std::cout << "============END FMS_releaseForm_1400" << std::endl; +} + +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/systemtest/common/fms/fms_stress_test/BUILD.gn b/test/systemtest/common/fms/fms_stress_test/BUILD.gn new file mode 100644 index 0000000000..cf6c4326c9 --- /dev/null +++ b/test/systemtest/common/fms/fms_stress_test/BUILD.gn @@ -0,0 +1,75 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/appexecfwk/standard/appexecfwk.gni") + +module_output_path = "appexecfwk_standard/formmanagerst" + +ohos_systemtest("FormStressTest") { + module_out_path = module_output_path + include_dirs = [ + "${aafwk_path}/interfaces/innerkits/ability_manager/include", + "${appexecfwk_path}/test/systemtest/common/fms/common/include", + "//base/notification/ces_standard/test/systemtest/common/resource", + "//foundation/distributedschedule/safwk/services/safwk/include", + ] + + sources = [ + "${appexecfwk_path}/test/systemtest/common/fms/common/src/form_event.cpp", + "${appexecfwk_path}/test/systemtest/common/fms/common/src/form_st_dump_util.cpp", + "${appexecfwk_path}/test/systemtest/common/fms/common/src/form_st_operator.cpp", + "${appexecfwk_path}/test/systemtest/common/fms/common/src/form_st_util.cpp", + "fms_stress_test.cpp", + ] + + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + + configs = [ + "${aafwk_path}/services/abilitymgr:abilityms_config", + "${appexecfwk_path}/services/appmgr:appmgr_config", + ] + + deps = [ + "${aafwk_path}/frameworks/kits/ability/native:abilitykit_native", + "${aafwk_path}/services/abilitymgr:abilityms", + "${appexecfwk_path}/common:libappexecfwk_common", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//third_party/googletest:gtest_main", + ] + + defines = [ "APP_LOG_TAG = \"formManagerStressTest\"" ] + + external_deps = [ + "aafwk_standard:base", + "aafwk_standard:want", + "appexecfwk_standard:appexecfwk_base", + "appexecfwk_standard:appexecfwk_core", + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr_L2:samgr_proxy", + ] +} + +group("systemtest") { + testonly = true + + deps = [ ":FormStressTest" ] +} diff --git a/test/systemtest/common/fms/fms_stress_test/fms_stress_test.cpp b/test/systemtest/common/fms/fms_stress_test/fms_stress_test.cpp new file mode 100644 index 0000000000..802c20f196 --- /dev/null +++ b/test/systemtest/common/fms/fms_stress_test/fms_stress_test.cpp @@ -0,0 +1,720 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include "app_log_wrapper.h" +#include "ability_info.h" +#include "ability_handler.h" +#include "ability_local_record.h" +#include "ability_start_setting.h" +#include "common_event.h" +#include "common_event_manager.h" +#include "context_deal.h" +#include "form_event.h" +#include "form_st_common_info.h" +#include "form_st_util.h" +#include "iservice_registry.h" +#include "nlohmann/json.hpp" +#include "system_ability_definition.h" +#include "stress_test_config_parser.h" + +using OHOS::AAFwk::Want; +using namespace testing::ext; +using namespace std::chrono_literals; +using namespace OHOS::STtools; + +namespace { +std::vector bundleNameList = { + "com.ohos.form.manager.stress", +}; +std::vector hapNameList = { + "fms_stress_test-signed", +}; +} // namespace + +namespace OHOS { +namespace AppExecFwk { + +static StressTestLevel stLevel_; +class FormStressTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + static bool SubscribeEvent(); + static bool PublishEvent(const std::string &eventName, const int &code, const std::string &data); + + void SetUp(); + void TearDown(); + void StartAbilityKitTest(const std::string &abilityName, const std::string &bundleName); + void TerminateAbility(const std::string &eventName, const std::string &abilityName); + + // Test case + static void StressTest_0100(); + static void StressTest_0200(); + static void StressTest_0300(); + static void StressTest_1100(); + static void StressTest_1300(); + static void StressTest_1700(); + static void StressTest_1800(); + + class FormEventSubscriber : public CommonEventSubscriber { + public: + explicit FormEventSubscriber(const CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp){}; + virtual void OnReceiveEvent(const CommonEventData &data) override; + ~FormEventSubscriber() = default; + }; + + static sptr abilityMs; + static FormEvent event; + static std::vector eventList; + static std::shared_ptr subscriber_; + +}; + +std::vector FormStressTest::eventList = { + FORM_EVENT_ABILITY_ONACTIVED, FORM_EVENT_RECV_STRESS_TEST_0100, FORM_EVENT_RECV_STRESS_TEST_0100_01, FORM_EVENT_RECV_STRESS_TEST_0200, + FORM_EVENT_RECV_STRESS_TEST_0200_01, FORM_EVENT_RECV_STRESS_TEST_0200_02, FORM_EVENT_RECV_STRESS_TEST_0200_03, + FORM_EVENT_RECV_STRESS_TEST_0300, FORM_EVENT_RECV_STRESS_TEST_0300_01, FORM_EVENT_RECV_STRESS_TEST_0300_02, + FORM_EVENT_RECV_STRESS_TEST_0400, FORM_EVENT_RECV_STRESS_TEST_0500, + FORM_EVENT_RECV_STRESS_TEST_1100, FORM_EVENT_RECV_STRESS_TEST_1100_01, FORM_EVENT_RECV_STRESS_TEST_1100_02, + FORM_EVENT_RECV_STRESS_TEST_1100_03, FORM_EVENT_RECV_STRESS_TEST_1300, FORM_EVENT_RECV_STRESS_TEST_1300_01, + FORM_EVENT_RECV_STRESS_TEST_1300_02, FORM_EVENT_RECV_STRESS_TEST_1300_03, + FORM_EVENT_RECV_STRESS_TEST_1700, FORM_EVENT_RECV_STRESS_TEST_1700_01, FORM_EVENT_RECV_STRESS_TEST_1700_02, + FORM_EVENT_RECV_STRESS_TEST_1800, +}; + +bool PublishEvent(const std::string &eventName, const int &code, const std::string &data) +{ + Want want; + want.SetAction(eventName); + CommonEventData commonData; + commonData.SetWant(want); + commonData.SetCode(code); + commonData.SetData(data); + return CommonEventManager::PublishCommonEvent(commonData); +} + +FormEvent FormStressTest::event = FormEvent(); +sptr FormStressTest::abilityMs = nullptr; +std::shared_ptr FormStressTest::subscriber_ = nullptr; +void FormStressTest::FormEventSubscriber::OnReceiveEvent(const CommonEventData &data) +{ + GTEST_LOG_(INFO) << "OnReceiveEvent: event=" << data.GetWant().GetAction(); + GTEST_LOG_(INFO) << "OnReceiveEvent: data=" << data.GetData(); + GTEST_LOG_(INFO) << "OnReceiveEvent: code=" << data.GetCode(); + SystemTestFormUtil::Completed(event, data.GetWant().GetAction(), data.GetCode(), data.GetData()); +} + +void FormStressTest::SetUpTestCase() +{ + SystemTestFormUtil::InstallHaps(hapNameList); + if (!SubscribeEvent()) { + GTEST_LOG_(INFO) << "SubscribeEvent error"; + } + + StressTestConfigParser stcp; + stcp.ParseForStressTest(STRESS_TEST_CONFIG_FILE_PATH, stLevel_); + std::cout << "stress test level : " + << "executionTimes : " << stLevel_.executionTimesLevel << std::endl; +} + +void FormStressTest::TearDownTestCase() +{ + GTEST_LOG_(INFO) << "UnSubscribeCommonEvent calld"; + SystemTestFormUtil::UninstallBundle(bundleNameList); + CommonEventManager::UnSubscribeCommonEvent(subscriber_); +} + +void FormStressTest::SetUp() +{ +} + +void FormStressTest::TearDown() +{ + GTEST_LOG_(INFO) << "CleanMsg calld"; + SystemTestFormUtil::CleanMsg(event); + // SystemTestFormUtil::CleanMsg(formEvent); +} +bool FormStressTest::SubscribeEvent() +{ + GTEST_LOG_(INFO) << "SubscribeEvent calld"; + MatchingSkills matchingSkills; + for (const auto &e : eventList) { + matchingSkills.AddEvent(e); + } + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + subscribeInfo.SetPriority(1); + subscriber_ = std::make_shared(subscribeInfo); + return CommonEventManager::SubscribeCommonEvent(subscriber_); +} + +void FormStressTest::StressTest_0100() +{ + std::string bundleName = "com.ohos.form.manager.stress"; + std::string abilityName = "FormAbilityStress"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // AcquireForm + std::string eventData = FORM_EVENT_REQ_STRESS_TEST_0100; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_STRESS_TEST_0100, 100, eventData); + + // OnAcquired + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_0100, 101)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_0100, 101); + std::string formId = data; + + // OnUpdate + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_0100, 102)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_0100, 102); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_0100 AcquireForm, result:" << result; + } + + // DeleteForm Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_0100_01, 103)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_0100_01, 103); + result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_0100 DeleteForm, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} + +void FormStressTest::StressTest_0200() +{ + std::string bundleName = "com.ohos.form.manager.stress"; + std::string abilityName = "FormAbilityStress"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // AcquireForm + std::string eventData = FORM_EVENT_REQ_STRESS_TEST_0200; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_STRESS_TEST_0200, 200, eventData); + + // OnAcquired + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_0200, 201)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_0200, 201); + std::string formId = data; + GTEST_LOG_(INFO) << "FMS_stressTest_0200 AcquireForm, formId:" << formId; + + // OnUpdate + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_0200, 202)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_0200, 202); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_0200 AcquireForm 001, result:" << result; + } + + // ReleaseForm Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_0200_01, 203)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_0200_01, 203); + result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_0200 ReleaseForm, result:" << result; + } + + // OnAcquired + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_0200_02, 204)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_0200_02, 204); + result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_0200 AcquireForm 002, result:" << result; + } + + // DeleteForm Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_0200_03, 205)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_0200_03, 205); + result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_0200 DeleteForm, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} + +void FormStressTest::StressTest_0300() +{ + std::string bundleName = "com.ohos.form.manager.stress"; + std::string abilityName = "FormAbilityStress"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // AcquireForm + std::string eventData = FORM_EVENT_REQ_STRESS_TEST_0300; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_STRESS_TEST_0300, 300, eventData); + + // OnAcquired + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_0300, 301)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_0300, 301); + std::string formId = data; + + // OnUpdate + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_0300, 302)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_0300, 302); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_0300 AcquireForm, result:" << result; + } + + // CastTempForm Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_0300_01, 303)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_0300_01, 303); + result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_0300 CastTempForm, result:" << result; + } + + // DeleteForm Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_0300_02, 304)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_0300_02, 304); + result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_0300 DeleteForm, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} + +void FormStressTest::StressTest_1100() +{ + std::string bundleName = "com.ohos.form.manager.stress"; + std::string abilityName = "FormAbilityStress"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // AcquireForm + std::string eventData = FORM_EVENT_REQ_STRESS_TEST_1100; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_STRESS_TEST_1100, 1100, eventData); + + // OnAcquired + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_1100, 1101)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_1100, 1101); + std::string formId = data; + + // OnUpdate + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_1100, 1102)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_1100, 1102); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_1100 AcquireForm, result:" << result; + } + + // NotifyInvisibleForms Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_1100_01, 1103)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_1100_01, 1103); + result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_1100 NotifyInvisibleForms, result:" << result; + } + + // NotifyVisibleForms Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_1100_02, 1104)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_1100_02, 1104); + result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_1100 notifyVisibleForms, result:" << result; + } + + // DeleteForm + eventData = formId; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_STRESS_TEST_1100_03, 1105, eventData); + + // DeleteForm Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_1100_03, 1105)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_1100_03, 1105); + result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_1100 DeleteForm, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} + +void FormStressTest::StressTest_1300() +{ + std::string bundleName = "com.ohos.form.manager.stress"; + std::string abilityName = "FormAbilityStress"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // AcquireForm + std::string eventData = FORM_EVENT_REQ_STRESS_TEST_1300; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_STRESS_TEST_1300, 1300, eventData); + + // OnAcquired + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_1300, 1301)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_1300, 1301); + std::string formId = data; + + // OnUpdate + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_1300, 1302)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_1300, 1302); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_1300 AcquireForm, result:" << result; + } + + // EnableUpdateForm Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_1300_01, 1303)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_1300_01, 1303); + result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_1300 EnableUpdateForm, result:" << result; + } + + // DisableUpdateForm Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_1300_02, 1304)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_1300_02, 1304); + result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_1300 DisableUpdateForm, result:" << result; + } + + // DeleteForm + eventData = formId; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_STRESS_TEST_1300_03, 1305, eventData); + + // DeleteForm Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_1300_03, 1305)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_1300_03, 1305); + result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_1300 DeleteForm, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} + +void FormStressTest::StressTest_1700() +{ + std::string bundleName = "com.ohos.form.manager.stress"; + std::string abilityName = "FormAbilityStress"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // GetAllFormsInfo + std::string eventData = FORM_EVENT_REQ_STRESS_TEST_1700; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_STRESS_TEST_1700, 1700, eventData); + + // GetAllFormsInfo Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_1700, 1700)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_1700, 1700); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_1700 GetAllFormsInfo, result:" << result; + } + + // GetFormsInfoByApp Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_1700_01, 1701)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_1700_01, 1701); + result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_1700 GetFormsInfoByApp, result:" << result; + } + + // GetFormsInfoByModule Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_1700_02, 1702)); + data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_1700_02, 1702); + result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_1700 GetFormsInfoByModule, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} + +void FormStressTest::StressTest_1800() +{ + std::string bundleName = "com.ohos.form.manager.stress"; + std::string abilityName = "FormAbilityStress"; + MAP_STR_STR params; + Want want = SystemTestFormUtil::MakeWant("device", abilityName, bundleName, params); + SystemTestFormUtil::StartAbility(want, abilityMs); + EXPECT_EQ(SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_ABILITY_ONACTIVED, 0), 0); + + // CheckFMSReady + std::string eventData = FORM_EVENT_REQ_STRESS_TEST_1800; + SystemTestFormUtil::PublishEvent(FORM_EVENT_REQ_STRESS_TEST_1800, 1800, eventData); + + // CheckFMSReady Result + EXPECT_EQ(0, SystemTestFormUtil::WaitCompleted(event, FORM_EVENT_RECV_STRESS_TEST_1800, 1800)); + std::string data = SystemTestFormUtil::GetData(event, FORM_EVENT_RECV_STRESS_TEST_1800, 1800); + bool result = data == "true"; + EXPECT_TRUE(result); + if (result) { + GTEST_LOG_(INFO) << "FMS_stressTest_1800 CheckFMSReady, result:" << result; + } + + SystemTestFormUtil::CleanMsg(event); +} + +/** + * @tc.number: FMS_stressTest_0100 + * @tc.name: 对创建卡片、删除卡片接口进行压力测试 + * @tc.desc: + * + * 预置条件: + * 1.卡片使用方A有卡片使用权限 + * 2.卡片提供方A已经提供可创建的卡片 + * + * 测试步骤: + * 循环执行下面1～2，直到达到所定结束条件为止： + * 1.卡片使用方A创建1张卡片提供方A提供的卡片，验证创建卡片接口返回结果。 + * 2.卡片使用方A删除已创建卡片，验证删除卡片接口返回结果。 + * + * 预期结果: + * 1. 创建卡片接口返回成功。 + * 2. 删除卡片接口返回成功。 + */ +HWTEST_F(FormStressTest, FMS_stressTest_0100, Function | MediumTest | Level2) +{ + std::cout << "START FMS_stressTest_0100" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < stLevel_.executionTimesLevel; iExecutionTimes++) { + FormStressTest::StressTest_0100(); + std::cout << "FMS_stressTest_0100 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_stressTest_0100" << std::endl; +} + +/** + * @tc.number: FMS_stressTest_0200 + * @tc.name: 对创建卡片、删除卡片、释放卡片接口进行压力测试 + * @tc.desc: + * + * 预置条件: + * 1.卡片使用方A有卡片使用权限 + * 2.卡片提供方A已经提供可创建的卡片 + * + * 测试步骤: + * 循环执行下面1～9，直到达到所定结束条件为止： + * 1.卡片使用方A创建1张卡片提供方A的无缓存卡片，验证创建卡片接口返回结果。 + * 2.卡片使用方A利用释放卡片接口释放1创建的卡片，验证释放卡片接口返回结果。 + * 3.卡片使用方A创建1张卡片提供方A的有缓存卡片，验证创建卡片接口返回结果。 + * 4.卡片使用方A删除3创建的卡片，验证删除卡片接口返回结果。 + * + * 预期结果: + * 创建卡片接口返回成功。 + * 释放卡片接口返回成功。 + * 删除卡片接口返回成功。 + */ +HWTEST_F(FormStressTest, FMS_stressTest_0200, Function | MediumTest | Level2) +{ + std::cout << "START FMS_stressTest_0200" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < stLevel_.executionTimesLevel; iExecutionTimes++) { + FormStressTest::StressTest_0200(); + std::cout << "FMS_stressTest_0200 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_stressTest_0200" << std::endl; +} + +/** + * @tc.number: FMS_stressTest_0300 + * @tc.name: 对创建卡片、临时卡片转常态卡片、删除卡片的外部接口进行压力测试。 + * @tc.desc: + * + * 预置条件: + * 1.卡片使用方A有卡片使用权限 + * 2.卡片提供方A已经提供可创建的卡片 + * + * 测试步骤: + * 循环执行下面1～9，直到达到所定结束条件为止： + * 1.卡片使用方A创建1张卡片提供方A的临时卡片，验证创建卡片接口返回结果。 + * 2.卡片使用方A把1创建的临时卡片转为常态卡片，验证临时卡片转为常态卡片接口返回结果。 + * 3.卡片使用方A利用删除卡片接口删除2转换的卡片，验证删除卡片接口返回结果。 + * + * 预期结果: + * 创建卡片接口返回成功。 + * 临时卡片转为常态卡片接口返回成功。 + * 删除卡片接口返回成功。 + */ +HWTEST_F(FormStressTest, FMS_stressTest_0300, Function | MediumTest | Level2) +{ + std::cout << "START FMS_stressTest_0300" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < stLevel_.executionTimesLevel; iExecutionTimes++) { + FormStressTest::StressTest_0300(); + std::cout << "FMS_stressTest_0300 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_stressTest_0300" << std::endl; +} + +/** + * @tc.number: FMS_stressTest_1100 + * @tc.name: 对通知卡片可见、通知卡片不可见接口进行压力测试 + * @tc.desc: + * + * 预置条件: + * 1.卡片使用方A有卡片使用权限 + * 2.卡片提供方A已经提供可创建的卡片 + * + * 测试步骤: + * 1.卡片使用方A创建1张卡片提供方A常态卡片（卡片设为定时刷新/30分），验证创建卡片接口返回结果。 + * + * 循环执行下面2～3，直到达到所定结束条件为止： + * 2.卡片使用方A对1已创建卡片实施通知卡片不可见，验证通知卡片不可见接口返回结果。 + * 3.卡片使用方A对1已创建卡片实施通知卡片可见，验证通知卡片可见接口返回结果。 + * + * 预期结果: + * 通知卡片不可见接口返回成功。 + * 通知卡片可见接口返回成功。 + */ +HWTEST_F(FormStressTest, FMS_stressTest_1100, Function | MediumTest | Level2) +{ + std::cout << "START FMS_stressTest_1100" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < stLevel_.executionTimesLevel; iExecutionTimes++) { + FormStressTest::StressTest_1100(); + std::cout << "FMS_stressTest_1100 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_stressTest_1100" << std::endl; +} + +/** + * @tc.number: FMS_stressTest_1300 + * @tc.name: 对卡片使用方允许刷新、卡片使用方暂停刷新进行压力测试。 + * @tc.desc: + * + * 预置条件: + * 1.卡片使用方A有卡片使用权限 + * 2.卡片提供方A已经提供可创建的卡片 + * + * 测试步骤: + * 1.卡片使用方A创建1张卡片提供方A常态卡片（卡片设为定时刷新/30分），验证创建卡片接口返回结果。 + + * 循环执行下面2～3，直到达到所定结束条件为止： + * 2.卡片使用方A调用暂停刷新，验证卡片使用方暂停刷新接口返回结果。 + * 3.卡片使用方A调用允许刷新，验证卡片使用方允许刷新接口返回结果。 + * + * 预期结果: + * 卡片使用方暂停刷新接口返回成功。 + * 卡片使用方允许刷新接口返回成功。 + */ +HWTEST_F(FormStressTest, FMS_stressTest_1300, Function | MediumTest | Level2) +{ + std::cout << "START FMS_stressTest_1300" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < stLevel_.executionTimesLevel; iExecutionTimes++) { + FormStressTest::StressTest_1300(); + std::cout << "FMS_stressTest_1300 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_stressTest_1300" << std::endl; +} + +/** + * @tc.number: FMS_stressTest_1700 + * @tc.name: 对所有卡片配置信息查询，对指定包的卡片配置信息查询，对指定模块的卡片配置信息查询的接口进行压力测试。 + * @tc.desc: + * + * 预置条件: + * 1.卡片使用方A有卡片使用权限 + * 2.卡片提供方A，B已经提供可创建的卡片 + * + * 测试步骤: + * 循环执行下面1～3，直到达到所定结束条件为止： + * 1.卡片使用方A调用所有卡片配置信息查询接口，验证所有卡片配置信息查询接口返回结果。 + * 2.从上面获取的信息中得到包名，卡片使用方A调用指定包名的卡片配置信息查询接口，验证指定包名的卡片配置信息查询接口返回结果。 + * 3.从上面获取的信息中得到模块名，卡片使用方A调用指定模块名的卡片配置信息查询接口，验证指定模块名的卡片配置信息查询接口返回结果。 + * + * 预期结果: + * 所有卡片配置信息查询接口返回成功. + * 指定包的卡片配置信息查询接口返回成功。 + * 指定模块的卡片配置信息查询接口返回成功。 + */ +HWTEST_F(FormStressTest, FMS_stressTest_1700, Function | MediumTest | Level2) +{ + std::cout << "START FMS_stressTest_1700" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < stLevel_.executionTimesLevel; iExecutionTimes++) { + FormStressTest::StressTest_1700(); + std::cout << "FMS_stressTest_1700 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_stressTest_1700" << std::endl; +} + +/** + * @tc.number: FMS_stressTest_1700 + * @tc.name: 对FMS状态检查的外部接口进行压力测试。 + * @tc.desc: + * + * 预置条件: + * 1.FMS为启动状态 + * + * 测试步骤: + * 循环执行下面1，直到达到所定结束条件为止： + * 1.调用FMS状态检查接口，验证FMS状态检查接口返回结果。 + * + * 预期结果: + * FMS状态检查接口返回成功. + */ +HWTEST_F(FormStressTest, FMS_stressTest_1800, Function | MediumTest | Level2) +{ + std::cout << "START FMS_stressTest_1800" << std::endl; + + for (int iExecutionTimes = 0; iExecutionTimes < stLevel_.executionTimesLevel; iExecutionTimes++) { + FormStressTest::StressTest_1800(); + std::cout << "FMS_stressTest_1800 ExecutionTimes:" << iExecutionTimes + 1 << std::endl; + } + + std::cout << "END FMS_stressTest_1800" << std::endl; +} +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/systemtest/common/fms/fms_stress_test/fms_stress_test_config/fms_stress_test_config.json b/test/systemtest/common/fms/fms_stress_test/fms_stress_test_config/fms_stress_test_config.json new file mode 100644 index 0000000000..706a917a72 --- /dev/null +++ b/test/systemtest/common/fms/fms_stress_test/fms_stress_test_config/fms_stress_test_config.json @@ -0,0 +1,3 @@ +{ + "ExecutionTimes": 5 +} diff --git a/test/systemtest/common/fms/fms_stress_test/stress_test_config_parser.h b/test/systemtest/common/fms/fms_stress_test/stress_test_config_parser.h new file mode 100644 index 0000000000..42fef5e6b6 --- /dev/null +++ b/test/systemtest/common/fms/fms_stress_test/stress_test_config_parser.h @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef STRESS_TEST_CONFIG_PARSER_H +#define STRESS_TEST_CONFIG_PARSER_H + +#include +#include +#include + +#include "nlohmann/json.hpp" + +namespace OHOS { +namespace AppExecFwk { + +const std::string STRESS_TEST_CONFIG_FILE_PATH{"./fms_stress_test_config.json"}; + +const std::string STRESS_TEST_EXECUTION_TIMES_KEY{"ExecutionTimes"}; + +struct StressTestLevel { + int32_t executionTimesLevel{1}; +}; + +class StressTestConfigParser { +public: + void ParseForStressTest(const std::string &path, StressTestLevel &stlevel) + { + std::ifstream jf(path); + if (!jf.is_open()) { + std::cout << "json file can not open!" << std::endl; + return; + } + nlohmann::json jsonObj; + jf >> jsonObj; + const auto &jsonObjEnd = jsonObj.end(); + if (jsonObj.find(STRESS_TEST_EXECUTION_TIMES_KEY) != jsonObjEnd) { + jsonObj.at(STRESS_TEST_EXECUTION_TIMES_KEY).get_to(stlevel.executionTimesLevel); + if (0 == stlevel.executionTimesLevel) { + stlevel.executionTimesLevel = 1; + } + } + } +}; + +} // namespace AppExecFwk +} // namespace OHOS + +#endif // STRESS_TEST_CONFIG_PARSER_H -- Gitee From 99b2976a5f5f046b98373e9c85b200b9ccea188f Mon Sep 17 00:00:00 2001 From: "zhaoyuan17@huawei.com" Date: Sat, 9 Oct 2021 16:51:04 +0800 Subject: [PATCH 02/10] fms codex1009 Signed-off-by: zhaoyuan17@huawei.com --- .../FormSystemTestServiceA.hap | Bin 0 -> 420471 bytes .../FormSystemTestServiceB.hap | Bin 0 -> 420448 bytes test/resource/formsystemtestability/BUILD.gn | 4 +- .../fmsSystemPerformance/config.json | 80 -- .../src/form_ability_performance.cpp | 372 ------- .../src/form_ability_stress.cpp | 659 ------------ .../include/form_ability_commona.h | 21 +- .../src/form_ability_commona.cpp | 28 +- .../include/form_ability_no_perm.h | 19 +- .../src/form_ability_no_perm.cpp | 20 +- .../include/form_ability_a.h | 26 +- .../include/form_ability_deleteform.h | 23 +- .../include/form_ability_releaseform.h | 22 +- .../src/form_ability_a.cpp | 189 ++-- .../src/form_ability_deleteform.cpp | 121 ++- .../src/form_ability_releaseform.cpp | 157 ++- .../include/form_ability_b.h | 38 +- .../src/form_ability_b.cpp | 105 +- .../include/form_ability_not_sys.h | 19 +- .../src/form_ability_not_sys.cpp | 19 +- .../selfStartingTestHostA}/BUILD.gn | 12 +- .../selfStartingTestHostA}/config.json | 10 +- .../include/form_ability_self_starting_a.h} | 57 +- .../src/form_ability_self_starting_a.cpp | 176 ++++ .../selfStartingTestHostB}/BUILD.gn | 12 +- .../selfStartingTestHostB/config.json | 80 ++ .../include/form_ability_self_starting_b.h} | 81 +- .../src/form_ability_self_starting_b.cpp | 197 ++++ .../tool/src/form_test_utils.cpp | 7 +- test/systemtest/common/fms/BUILD.gn | 4 +- .../fms/common/include/form_st_common_info.h | 76 +- .../fms/common/include/form_st_operator.h | 23 +- .../common/fms/common/include/form_st_util.h | 10 +- .../fms/common/src/form_st_operator.cpp | 50 +- .../common/fms/common/src/form_st_util.cpp | 13 +- .../common/fms/fms_acquire_form_test/BUILD.gn | 4 +- .../fms_acquire_form_test.cpp | 828 +++++++-------- .../fms_delete_form_test.cpp | 469 +++------ .../common/fms/fms_fuzz_test/BUILD.gn | 73 -- .../fms_fuzz_test_config/config.json | 29 - .../include/fuzz_test_config_parser.h | 79 -- .../fms_fuzz_test/include/fuzz_test_manager.h | 58 -- .../fms/fms_fuzz_test/include/get_param.h | 394 ------- .../fms/fms_fuzz_test/src/fms_fuzz_test.cpp | 74 -- .../fms_fuzz_test/src/fuzz_test_manager.cpp | 215 ---- .../fms/fms_fuzz_test/src/get_param.cpp | 477 --------- .../test_lib/formManagerFuzzTest | Bin 246288 -> 0 bytes .../common/fms/fms_performance_test/BUILD.gn | 75 -- .../fms_performance_config.json | 3 - .../fms_performance_test.cpp | 965 ------------------ .../performance_config_parser.h | 59 -- .../fms_release_form_test.cpp | 503 +++------ .../BUILD.gn | 8 +- .../fms_acquire_forms_and_self_starting.sh | 43 + .../fms_check_self_starting.sh | 34 + .../fms_self_starting_test.cpp | 217 ++++ .../fms/fms_stress_test/fms_stress_test.cpp | 720 ------------- .../fms_stress_test_config.json | 3 - .../stress_test_config_parser.h | 59 -- 59 files changed, 2016 insertions(+), 6103 deletions(-) create mode 100644 test/resource/fms/fms_provider_ability_bundle/FormSystemTestServiceA.hap create mode 100644 test/resource/fms/fms_provider_ability_bundle/FormSystemTestServiceB.hap delete mode 100644 test/resource/formsystemtestability/fmsSystemPerformance/config.json delete mode 100644 test/resource/formsystemtestability/fmsSystemPerformance/src/form_ability_performance.cpp delete mode 100644 test/resource/formsystemtestability/fmsSystemStress/src/form_ability_stress.cpp rename test/resource/formsystemtestability/{fmsSystemPerformance => fmsSystemTestSelfStarting/selfStartingTestHostA}/BUILD.gn (91%) rename test/resource/formsystemtestability/{fmsSystemStress => fmsSystemTestSelfStarting/selfStartingTestHostA}/config.json (83%) rename test/resource/formsystemtestability/{fmsSystemPerformance/include/form_ability_performance.h => fmsSystemTestSelfStarting/selfStartingTestHostA/include/form_ability_self_starting_a.h} (54%) create mode 100644 test/resource/formsystemtestability/fmsSystemTestSelfStarting/selfStartingTestHostA/src/form_ability_self_starting_a.cpp rename test/resource/formsystemtestability/{fmsSystemStress => fmsSystemTestSelfStarting/selfStartingTestHostB}/BUILD.gn (91%) create mode 100644 test/resource/formsystemtestability/fmsSystemTestSelfStarting/selfStartingTestHostB/config.json rename test/resource/formsystemtestability/{fmsSystemStress/include/form_ability_stress.h => fmsSystemTestSelfStarting/selfStartingTestHostB/include/form_ability_self_starting_b.h} (42%) create mode 100644 test/resource/formsystemtestability/fmsSystemTestSelfStarting/selfStartingTestHostB/src/form_ability_self_starting_b.cpp delete mode 100644 test/systemtest/common/fms/fms_fuzz_test/BUILD.gn delete mode 100644 test/systemtest/common/fms/fms_fuzz_test/fms_fuzz_test_config/config.json delete mode 100644 test/systemtest/common/fms/fms_fuzz_test/include/fuzz_test_config_parser.h delete mode 100644 test/systemtest/common/fms/fms_fuzz_test/include/fuzz_test_manager.h delete mode 100644 test/systemtest/common/fms/fms_fuzz_test/include/get_param.h delete mode 100644 test/systemtest/common/fms/fms_fuzz_test/src/fms_fuzz_test.cpp delete mode 100644 test/systemtest/common/fms/fms_fuzz_test/src/fuzz_test_manager.cpp delete mode 100644 test/systemtest/common/fms/fms_fuzz_test/src/get_param.cpp delete mode 100644 test/systemtest/common/fms/fms_fuzz_test/test_lib/formManagerFuzzTest delete mode 100644 test/systemtest/common/fms/fms_performance_test/BUILD.gn delete mode 100644 test/systemtest/common/fms/fms_performance_test/fms_performance_config/fms_performance_config.json delete mode 100644 test/systemtest/common/fms/fms_performance_test/fms_performance_test.cpp delete mode 100644 test/systemtest/common/fms/fms_performance_test/performance_config_parser.h rename test/systemtest/common/fms/{fms_stress_test => fms_self_starting_test}/BUILD.gn (93%) create mode 100644 test/systemtest/common/fms/fms_self_starting_test/fms_acquire_forms_and_self_starting.sh create mode 100644 test/systemtest/common/fms/fms_self_starting_test/fms_check_self_starting.sh create mode 100644 test/systemtest/common/fms/fms_self_starting_test/fms_self_starting_test.cpp delete mode 100644 test/systemtest/common/fms/fms_stress_test/fms_stress_test.cpp delete mode 100644 test/systemtest/common/fms/fms_stress_test/fms_stress_test_config/fms_stress_test_config.json delete mode 100644 test/systemtest/common/fms/fms_stress_test/stress_test_config_parser.h diff --git a/test/resource/fms/fms_provider_ability_bundle/FormSystemTestServiceA.hap b/test/resource/fms/fms_provider_ability_bundle/FormSystemTestServiceA.hap new file mode 100644 index 0000000000000000000000000000000000000000..b2fdf9c2d257585d8ce5254fc9edf977127e7d61 GIT binary patch literal 420471 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%0A$>dY5iWICGi-&t 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

jkRFT^5!`K3ZNXPat}XIRXMhm z{OiOCjiGvc-lXQA9-(P0Zz9XK6>JiqjMg>l!KhA8kP4sxGaf#;=xBr+c3~+bu8xLF zmBN3kW;`h*8lrEXbj2Z1#fIi5Kc!{)csrLnf4oN|dkT(Ak0ve4A1C;m*0hZjjNL|B zy1Qb&WU>|>fc5+XkEVDvX`zPA2zEzo?nTMS`qFJ6+=s}3oH;*q z7C7jADmf(Bj@Ijy2L+8)xVbWKNbrI%Nx{J5u&U9A3R#`7dEoT=)g;+b7`M#mX$g!lT@H_EQbTIh&2#APEaIQ!Y- z+O1nghD1Mf_1w?23U$ZXqHU?NL(mLy{{Yvjjd0S-wpIagj<^D)HqiEE!!?z-bX-j5 z8E&}t&-v+0^Ss0-oxY33M;)t>h!kM9S&7KN{{ZWA_|;8YRM_hkq+fUBP&1RwIIFuM zH)VEg!lotMfq-Mz9`xwRc|KgO2TXJ{S}QUsd4|s{GYsP$IIArZEMiTre9i)3l6&%N z8BWa6M1i8%@6K{b#(Vz&hf0KQ$qj&|FvB@G8OP~Y%7%zDZW%&%0zQBbuQis#Y7w-8 zM^3q=7jd;>rPauYZjqUY>^cwfYc!RSr(#RDJP!PKH9XRxkr3H)gSONiC2 z*}TFsLyweuR?9?W^(b8a?j4ExH>v$x(kh-7|Zr!-B;PlQ^~}H%dejt zL6dxgFS&_v^k4C=M^(w2s3@W-E|6QiPLZri*mZxIvN~j*^+?}s8H=GKJdS(SiBcmI zTu*eO1Z)LTrO)fv+Ne(ys~b#^x7o?ck^m%ofzq_6%E*<(dzm9IkV|wVoYg62Ehg3t zpZ0&knIn?pEC?qYQozh6QmBBh3d}QIDmF$pxcAAoTWDYnaQx+o7#`f>pFO>;rl$-N zJW87hW@*0jV}XyYGQtyOd~TuICMSj}PARwc5FcGF8FnPo`EK3i0XJ<>4fld#UTd4M` z+BTGCw^KKiSe?Up$p9MHmqY&1vo{#?3W4`Q+q+d)nFol3~|V%LvmvUi6h_AquKLmCRaVSG#c{k z-!vOi+B7BIS17pmsMVRL^FGv}BL``WpP2VGR&Cxuk92ZeKg{QOES}Ws=x|N7>r35=h4~O5-{D5^6ZDR>5v1 zySr4CM+&4C7#vk!wTqZmd0|lq&J3CAc_*!3#j!hXOp~l;X;79i6Z1JNPt&F;mvaj^x+{)8H>584e@d-<@5y((NHIvU&_GU$i`|Cl#}Q?sItt~QN8?bkpSy}r_9{V?rHPOb7?z8 zDs7cV$`k?z)}e;)?DClbQpHM#BPRx`EYsXw$>rO|LVU%6JDQq<+3bUvbR{~Eh)E@H zWCOPpRev(*{{YW#`{dDA$h#tWpLTIRZcb?nZgab#=xK@pQ_c-Y7X$AM`eMC<%@|I5 z3K)_w0l@U7O^jF?nK)7dWKbcYvk(P$59LFg0>8pX9CW3O5;p_%#WT#^xmfY^pktxj zRPMn++LcfS%Jd_TdQ|~FMqH^Mcv3*a1#o)sXaT!>b|>zeQ0R$d!X+Xjew-f-!$s@4$r^Mlo)^47(m?N)V-iDe-Ad!ro zqL>msQ-Q$tpaQ=(bCNSnQVDJR;*)sWg4xGP1Uq-l^0`r-Gg2J6&JRwxsJTBOz~dsF z^9(L}`kFvV)BD>`T59b)a8vuFQ%306sX6><8CL*|@OkGnz$An+Wd=FqW~;ieI6qNV zcdJK$#CsZZHgG`zW2GP}?#KhLttT6ZJ^R$`i0hn%KHcgw6CxHX$4t-w1_>l&de8?P z^vyH2Il-V3q_3?59>5%9G^cLvdKzydoN_4d*CVw69-#FU)cHUPARc*$p)Y!2Yxe(o6O66xLk?= zQ0*H94OSJ_RRHitb4^mDeB*QDf;-a+5EbJ&?m?gl8GOH+8SU1uSnGFI2M70w&;~s| zhuWxz3iu#xW1LdrHw9GS=kB#jN$y-^)~M@X)wJ2|*sGMdJP4lvZtQbbUf}~tx;7;- zh3r{;GBPe`=duOIN?0VIkO;<>|u`4VF-u*H|l3F+XI~s+puM$5!L{ck}g07?k>BmYE z?hW5!yU#b4u`BFc?_94h$6VA8BJCj##W!=|;X^2m|)|@#Q6!13;V>mgc>|in}4G&Zvr!SyZL7aU( zDQX2W-#^{jDoC3R$4`2ltzfuZ!6%mF{l`3h2BDtH=FB0M7Da!$#Bkq3MZ&|K1A^St z1#oz!4#fI;)3)))G{K@U#8k^ZF~G%FJbKVEK_-+KxNWG|Vt59fEwd=yA{8B&4h?1o zDtJ8Bt)8_c5eTG3c)`gBoYc0~#m3!AGQ!LAbsp6L828O?rS6+>51R`|A^s@H1M=xr z=CX=V&u-w1^gU=&?l%s`YPnv#QkhQTDenWuaLRuwh^Ys@D#&^hq4PLDts_T@i3t@d z$=J{#0XgedA-k5|Rd}UzW$4OqL8dYW1(Kr9I`*Ur>tnsq{v&D@n^Nso=|%u!!vXzk zyRq?(nW;uqryHB3R~R3cZ`QmaTWRCgtjBcg)aUT7YM59{RiW8W6*#LsPjk4^v}?u% z^u=}yDMpDix!%x;kTCjJH-h#L#RvZ-U=WjeolFfZwf5)@rH*ma!_a z=L!h?4RALakZzIliR3i#TI(r|&h|sAnr8@NE z(Cu~K2w2}jWYa>W!u3JGZ>OQJJJhsGjXrY>@iI6Z1{kiNOZbaCZ?^I^Wn;{UFh}8A z_cnI^Dz`GleH*d+tZ)kc9jl_9T9jWcO^#aFdR5moJ~?%L^cw~cN<=XeLx z=~%pFIcVEQL~s=$(MYBL00>@}Z~=<`Sc43%DUa~&nXzxITDAso;H_*~Xg9te z8{^g^mJmSlq=$MD>x0wqt(4Z$6a6DciegtR_L6NsU9J5MVDU9m_a$?6f}tgO!pz`g z_<5}^Olu6ow#f%IpErax_zB&n%6-7idR?xs;puKj7uQy7-@|e+bM@`{*FpA4S{>Gx z@y(HtS@WODpVzBL;za)dW#Q-WxA&e3+D4%cOqNr}>P%-J%B#z4SBVs<$3ih)_}2R3 zv|zz!EL|UY!TOA5soq;(d8}mc^{vc(h?H*qMOw^XRrr}aq6^`ZJQaq{2qK%ghZ(PJ zlR?sTA2aQq8J++++=O%aR!zr%JUuuj6R6vIW+KD+R={-ktdh;g3P)626?R4Qxg%=X$+X{PU2BzsN|9Zy58Z?`w}Zo)5TiNgkmJQEf_h&bNbd2$O*?v za~>)s2v6chu&Y*^_ghDx>Hh!{e5A$AfM)K<-DjsF_$t&OtJWhN0rEzcrF0%UX$SKOFI~R_KSSYz;XxaUSbAKZfP3yntHN3NKl{Q zB8*feQWl6{s#B#>@;z!xxC!MMh~V>8E)wQqUI>h7*MGOLsy-doA=QXTpmG7~dVNW* zrdz9M@T5Bt!NC|6;mJx8wU48NjN{CnhHajnCL!+re0|W}Xzb==XLB^lZthhg9EjoLlh~8b z%vf1gU8QtU_v z9C5`%R(2^nq0fvRpl2NksxL9#LMb@!=~knQVsgyIy62@YkgkM<9{i4KlM_W21+u^# zp1gjwUB}CV&-v?8&kHDErFJ<0FPIK}c+a&%F?dt=yAuHAi5!#dRl6jiKKDl79u7G} z-`=s_ISLsR1#k}RDLs8ZI_Na<4yAYZhQK&I2|wi5K^~uNYC^1IaO4xotv#o+c4*I& zpHqU1LDVl*e5-j1oMJ~CS023e?OQe;5=fh6)zCQSWMi+?n(CzzG;QTLkBkC(55l82 zD-3Pr4>8notU z)kyB8dxtkFQAT{WB;m3AsV75ma$;M6jEk1zB!kkiyqou#rJ|OI#MQ3mp5R8TTWP_` z@BV+CExwU^GobRoUN<|QI{yIr>!z{MZS4q)>_AcN$LmzQM|SW# z=4oP37iyB-Iy9jdICZ#LKv3=9E|KmAlirzlT0;35p;B=hyf zYdLd#TXrHVmtiEiy1tWfc?dtk3F4)I{gsnsuJV!h6y$y;mwExV0#OfE?tX%-+gmAx zkz-_5J@|J20P9wAX(EzskeFt;ZSsa}leIzMel;(V6fu{Sfyc@_ejc?w-SR;a$Hw4t zsJ*_mj%1SVVdgsEkPo+NnBHDUZpe|Y-H*!HQPkqAF^rQTa_rqfKb2TE%WiltAv^$o zng0Mi=>>xc6tX*$$l5ye;MJ)_mYG#ihX|MOa}TmlBzj zPbnNA=)a9ppHnvgp&YLm#{i#dT+)}q9I0+wn^Q!$mOFRnXDkQau69Wzl2G4xk;3lp zR)~?Z#5Vr`?uv#*OKAMY0Yh{?2Ri`ZA9`Dh znI}=@zS9`M7{&*#DJ}s8vz?^;svD17RjV68I)QMc&LgeZtt%34)%)8`nKs*88A5J>ecf5$JDA>{wv;+4} zI@CAUmn(@e`=WNAe_U1>ovrMgmJPX%zyM$CPBh!qiOnsG8lCJ>GQn)VYmDv*gSXzY zZ*Jm9<0pHvzs^D63=9n8j+K`?NeuE_kX!B69jz2jaK|0br&`suR0oUhjma-w{kO6Ez0?3 zMz@wjDwJSwxKqz0pYw{(X1a^Zh|6hjW`lbCzq})!KQmmaa+B4YG?LJsOS_i0l0=C- z$clii%8#h+{{YsgWJ`cnXka5BD4H+}56`wLIaX<7jV%C?wtC#HhE>$%bpIm&7`1L@|QF zGx&j1Lu)EX!f8;+jO+jme}_ua7s+6(qS8b@q4F4a!5u2Kjl8OwC8@`rAIDO=vQ~jAEL{l?ol{q6mr}3$wvUw$ZnDCh0BmLa<#%o&I&KP5plWz{) zqju5XuUe;lf2J79v~4^p-zmUA4_@7CK6y*wFO@CI5!x*GEgr>@#zRP_Am`9_$31HK zveKc2UCc3`EFc|D;olwm{*{h(qFXUSkOf_-9BY6_x$jlhD}#KuH!+Z`4$*=KPyW4A zrzg9yDr=#jy1l-g2{Gw}64~=)AeQiOjM9azM@(CaT!RV};t{QJFD_!wkRp3Y=A43|;Keq#+Q zM8}tq@=x>?N}R4sk|&1Ca)pO$4yCj5kH?D2xVU3<>GqtJ>#*k^Oj6$K2_2-CcJ||W zljfP9Ac4>UR3Vt8xKt|M!n&!#TDD;+Es=Kc!4DQTM+^l<0p18+-4A*Im2z-*40q?H4!d6?^AyEaJGKrx;+U?i3bt}O zPz8a)XMzu0Qn-jmfKCbR%|s+2aezqeLo)7NtHwDVlmM&_Py>a>;YLt`n+R-r(IYO< zK*lKwmH~!KPy@bJO~Ru==42i{Dajt-e}$K?G{S`Z!15>pQiIFMKQQf1G7K)!l6r$t ztCoz07-8*ARs`Xcf$V4oIfE$&pJPfm87Dk?Qi8)A&uMMTi@ zagsY4a?07kIXL5t(yXUu3Wgq(fQ&0H0o|NaNdS&8d)1GT+i1ub>z>I2;^O1}a8IbJBngoO;vMx`ET$ke)hnX$bB+Py~qBVgc(*kj>6` zsK?=h(w8IXXaYumnMgRt>q`^9;0H>CHbKeH)||N+Dtdd+1)#!GL-nUJ0~S@X7q6{S zSu)rsuX=EHicAtu(t)Dh^N=3}MuNlc&Zigq@_aN!T$1Eo}2u$pC7hG|ka9SPc-fEoO1 z7KMVDG4hAopF>)!42to9jTmLga(?b}&lG*09g4DCM%ZAX6!qZq$EWqD%u9ip7aa7d z1{;o<=~hLYUSbt5^D!960Q+XG{{UfL6fPAu5<=z1PAR#?Zc3*ov6MqEy)|SYyl65S$nqjsnTXr8CwK&sZqAYb6;}R-k8xYL+AaLQVu^F&oQ#+ zBk--LwYjzhxs5JxFs~*{DD(%lC^~J~kVewL#Xtf=A1%i{20PMHlHCo$FJ@rpj8jiN zKPuU{(I!P{As&1K7?Ap*6ISF-JnII)XW>Qcq(y7Pl(`LG`OKUCRt_7&u7) z4elzxw=@7cbCFC**ywFFJAWnNl??u71|O;s=~pGw^qDP{%UoNzJ41Z3AwPx>^R7%Y zD+0L~?^fczmNpxRagVy=AXGR#(>9Gow2`>}6P9NG0EuQ_E%$+`{o?ZH2~JHM}g%fC{b-e+pT&3mIGe9M1`1l?6)=r$LiPwo67oVA{H8Hp}Il z9!FzM+zoEe;mfEaEFL)%uqOtyB>8zp5xlAMR4oJf5NN0 zaz(?b{Hij|yN;ffL>J2kIgf|!QZA(IM0ZQ(DD3@5<5|Ja(w*j)8(3%SO2bk$9y@uP zF*lc!_fH^xJ!vDB^G}pX6UiCu$k_aiW}z#@ZbmyAw3mzq*B{|P@2S@4elwC8e2rZ` z)dL)teD7W{+o-QXgH6!y?V-Fjc|rprNgEh7;}QLuQS*mW{p93+RqMVI)bu!XTT3YQ z2ZAJW3TnA zcRG_Q?2qNoaniY=tjB)XdGR8%Ce{RFpHIW}t_X8(j`>?*msX4>Xx~w{Oz=#H81<~u z(yhiV?yV+8Q}Y>6lb>T*-Y)Z4{^ie>6alw@TfQrSc9C!AjUIU3=bu`?B&}n= z)vR?bMRzJjPT_(bLajw<;hk|~X=0ic&tQw6OmG6lJ>Ct7-R8 z+-a~}Aq^X@{10B3KaUjZ&ZQM)u&Gn0UGqK6`(0DUS~yuHjNe1h1|iSpIjy@7h?Y{g zO-9~(2~T$2xA}icr**4aDl<$JNUM>KFe{zC@tvL;+=XI0Fx)bJwTiV};rAOm)7pP| z>NdC5_i4V~;yIA>nAkRdDwLKBh6Jhh#dwPNrETT&H1tS4S~UQgm3(!n!sPv@dwM$O z@u_$@eUg?gJx^v`hs__xm347o z_V8*`4a2OTH}%bE>E3m{ls5OXn~9WRr@$MBxc>k>E2230wXC)DIi;4cEZUZy1~&lG5X5~kT(9;fpzk8Z5SPn1ZHy1;*1g+N@Z>thyGJ~w?TN~+FjLb8 zu-DEM z0BpgoA8)PR=cVjYR$Cmcm57d9Wu$d(7@YnUs)*1D41tspoMRu4y=WgPbFdZv0Ip~S z0`4Neyta^nF_H&Am1gJ6%~W|&n{i|0+pLE>ir}cp+%drR`ukN#K!A&jh53*bKu5{| z<372q?=_|jc1am0Zy*fz=xUUn9Sk6^N;790AO+_Psg(Ky#ap*Ja zQyo73WmYmMQh8i$BkNL)Hg+rljd8##rz|n++nPXgx`wFMQIj;GiiN~wdY6f~bE*9v(V9G}9OG@A9}Ng7-EXifuU0KT8(Q|vU! z?JhUm{h4HC<;;cKJ@7kz6gwq$!Cv-Akj?gW+a|?Tp?8jo+P8NUvnw9lfk@u5r3o&tcqgS*Dqzx-;gwzUA4U1CTTHHP27>*Pk=p z9fLjj>+M}P_H>fU1=Yzc=NXMb3)=_$Ye76AV&8g6nMWkE0npa)sZJZ1N)w*P9ct3c zGDiV+bCS8o9ly`ktyt-ox~20ApD|(za^(F-71~+&XHT*sL4rq2o(DP2TPtceI6H_q zAR3wC68I3~LH(v=+G%#SEBly)ham27IN%OFDhumLH96WGT*hJ>gsO14^!KgPBvI`Q z$r#QyvBA%3bg{}}e=B)#q>YL)Pvcz5a=p%n1#29=lv;{gmXb!0#z>QRZT|r90n?>u z*hJS!BQzH=H$?N006*HTOITzv@1M;N#&?C!>BkjAQN6l|x5T|skz+>s_`crap zVzP=X+uIv>lw8l}NHfmRGx$|W+`)FYQ7k4IFsFN9gX%k1KMXqD?&Y-!6-fYm$L1c~ zRQ~{HXh8F2X9{vRv2J~ZTY^t=Ion$s7y7NVO3|aqBc9QmezlJGPbl)`059;sjh=gC z)1!_d5Rk}`so|N90RI3!l=$y0<&(+NS|)M{Gyebz)|363(%`h}ZYLN!x8M_5*ZR!&1)&Th1o0XSRmI8dOu1I% z__whhTp=WoedCTg_ccmVWs^Dc8#yG77w9|GX|f-l>47=gBVI}R(%nZh5M?bKV*|=T z+x?^OS|w&fWt(5J$GRye4CG|VwEUy|eW@;W0O~*$za~X!?Smc(EI#q~HBMsBGQ|-I zxqej~_o*$k@ZUYu*dSmW^u;SB?=Vg5im+L|{N&6Es*p}QR+CvZy~`zw%e97Z$S}C) zty{N)WH}MEQ0MPA@qdj!`%d08A|kQ&V&jwfbg7j|H=#-iZZ!l}#bmlUeYyVtYySYP zRi)IPRAhyOakfVtPx#dhLsErg1`=j1oxqF%{c4@H-NTcZe5Gdl=z3F)CvIjZQ=%@( zG{IZUeW80Eryt6ovsl#RNzUS3*nkB-cv8|Qcb#2aa5m(h&ZyhiUg}Z3#k6svA;*}* z3;0%vN0#@{&9`#wdW)m^5W=OHmh%T(Q)JWH=HX|!a(9jw&~a8QVNE9A614hNh?h&@6K4R8=NZpb5Q4J?)~FYy7!3E(Jic_RDGpM-1*5T{3N8j1wp*EIRg_9wmBVE9;QI>A$*p8sN$83e_JxcwzBxP~ z`H!(a)w|^Vf<|437+e-!IPcc9>~y$o<7H(~NylzE&Ii*biFW*<#!lge3Q5PIHO(rn zY}rGV8Mk*xOde@Syupu|f}9e0=AUZz3X#lEIFRl}akLN5wN}2FE^f;`in&ZMnaDUj zI2``~N}+Jg0QFU<=tGvK!PQ`%;g%L(ko?#f9=x9Qk8`NqOL2n{ zjvRcMaB>G6U}qIl-pbEVl1uRvk@rc2@ys+}PC58Y|w`lrSv5Zr(o0Dj* zsGE62Eh_JsNy*#LcK)@WmfI zvi|@H=sH(SbVf4VuXiL-FnN`Bk&uzEUu<*&pA?c^D#sO(QzU&C0P)cJlapH7ev55w zFPk8qSxTRlBb~m)o|VvBMiLSuf-7J~6(RsP)Uo!@9cww)iqR{MG~3mfI%b!682zC< zvZo?w25uE<^V==!FLq|_RoHCRaQ)2HM~}` zoHiNL{Zg+^r;}Js^Sw=Cxl0o2S2JHCn^~64MigKIJ;=>0lO@UWI9O4)G?L&bY;*^? zt3TP_xlsl>V|LyEA6~Te(~dUFwd2}I2N=ovaarCS3$%(??x}YZLm~~T5z9o}oO91Z znrD&Zk2TdAT%RaOCKm+s4OStrXxOE^fkAFriE=&1H8!iKi~C3|cC&d|Q0Ibko_hAp zJH|FbvwE2piRJmgmHT+zum&;>-^-;MeU;V4(URj(x7-wd?Oy>$uh-h0r|34CEYZ$x zOxHViVaX(V@%YqQrH#y@MbqI%kes##IXx>y%gye+`jM@*MwDJi`$Ps!$_5K(?;gke z^u=UqnqAecvK=AhK4=^B#!h;3RBWw&#-D4xm&=$BmJ&(H2hed^vFc5A7%TpXZU-TL z^O_wu7j*7{Ni}9=#iL%Vf$y~ifn`kW9Go7x>?=YW=KC%!5z6P8BQ21l<-sGiD$mN+ z)5+z>I4E|kl6=H_cFksKz^0VBD&V+j2H-J+&}Y6WsdFaf(3@G=57i@!cMS22u}w}kwA)~L6LNhFs$ll+l0;}4=x^pD6hh|*u2aFHH z8Rn`rQdS2Wvb6A-u3<1U4!QYA$n0@a+)4Ikk`UXZBLPp|-S5W$RP2orY1L3XpsKko zyYK|@Nb_ko!6P~|`tNL}tt^LIIu(B|UIVKV- z5?F}bW0CJv8%vooCcj7&g2(5aH~6>F2J5Q;uSBjB+f-Gx|-Q?^qb#g(PT!tG^HbS#^$G2)1ytQI(&qQrc;ypgb-D0%!V2&|>6|uPc z`sd!U?)Ay8WKG+Ze(=hi^XXd}WtNo{ypdc+g=1{713dZT?0met_dN(*&pLuNho{F%{MIy7Yt{T7@`I>Rpf0QYFLbs zOrIdhJOF<6S^Fio+88p;kej$U+}?tpb!LkMa)A5ufS}-m-j}qFhNHdWYz$`@ zN9*W2 zQ;coNQNZL1L;Ka>0K=%J1Zr9$cJrE(%uSy%_oY*Th8R7KAy$(tG43e=R03sAr+gMu^Hng%tQcP?|! zwKV*)44i{Z$=X32RHUoLk_a@!D>Cil2hh_Hk(N0Gbf&f!ZVB5?Dxo(k9Cs7|_5sHA zKQQa>KwwjFAUAP}L@VVS9&zbS$R3A1XaVX<Srm543E=if8{ zD-3i8o|vcY+w%qDnhwFjf;)rOmpM~`@{ZZFJJxjw&?_q?7k( z0l7WLN=3@HSR5LD2svSqPmp}8jQtG)BPtb!*8EL5@DyP{_Y^#MP%(-@xTXpAGyvoZ zNgu>G`qQE%LFzX4rY=A%4p-2MO~4L5@t_H}M*O~@GL#9J7=RiK3dexV9z}?T+nsA0W6gLUo~8`l(TdkeQGAlH*P8H2v7|J5VNE3 zezhPheqo-q7Bb^@X+!MesLyHuu(Rd1Fb(*0shTkBxq5-n@l;rCZR4TqQu&*cTwOO<|OJf5J?09OZ$j{MY+-AivGv~0ks%|n*x z)TP!_<&wD_Xak|sHQRN%-+0#>UxxDE81>+c8q~VfZKSsLZ)x{d5{+sZ9+MpaiR81&9+uGZ*QPiAFCWn_({X4+T|3w+q^`qZG?{LU4)`Im6u zdlUIptIZnzHEW2}PQ{64gn|dY2S24yvW`jRkU1q)4g)p^PkMaGtD;(I*_WbdZf&G_ zJjOAC;XubH1N{CJ#=Mpts;eUH$;f`B_s?;~R#^_sutGQo_k@s7uRn!9@5+niZ`=bY z*h$D7kEJVXsaMlNWWKnSLPVwfmh(404;jxtr7Z7i{{X&o68VgIj1YMC=m$TgSB)7N z%Q6khODO69rp9eI?aozs2OM(j@ZFlCXqq)WNOM6cVgKpE2^`KxuBLfv5Ak>69ADADhq+P7tGe8J3dees= zjXAJ60~FHhlboMQ0Dj|)iafwJvBw?iJ^ipK6oy^0)Glo0S#76y-A+`4$g7gyE~RlK zmqax39J}|=tz%;xf%O#q#~lygDOq0QyS0mRTC{7BL$CL$zmUucRSXARr#Pu$oz#8o zk3&`w)!QmIH}{m|HCH9X%^>rPb>vfUD`BFxxNWB~{J1UmvVCg2`ee|lk#@-#rBE zp%|kE7~`?1loXM0sN#0}9K`CeE1@g%^(6X#pGvVGnHYG9j@?JfT%HtqS3hU28-`eJ zXD}c?z%ViI?N^d0FA$ZMHUKgCoAJ*-O672CbG9>5)fzM0*+@|?Vz-z8H%Q61^1;u1 z)_v}spv&d`npvPSDPg+=b@b{hHfy-yvmqibt;X`C3dw0%_Oy&gpaQgoH_@3+Y3_|_ zJU=!V+T6o(7bgnXY!73K%AVGETWqk%pYJIZJ*DA_R%Hj~QZb&jsG8*I2uF>ijkpNF z5n5hL%*&P!$mf7L;-0L)*FdXbc&IKczRn58^gDR&eJZ=?(9FzjZ=vAuvYn?N%9^OU zi`hPgTF42`F^@{Ll6jaU?)MxTg5t_+SxU;MXgCbKgZR`+#R$PUtG&t98`e6;sbRQT z-LpnU3Q6-1$mCVaKNT1W6WGVN^)V8gx(-0%xrpux@J9!lu$NG}9D|>JYdKPcw?>hx zIPA|twbrz4QU&v&F|!c3Y5wv2sScf@#IJE3oF!GZfg$0JJ|-dny-7U7oRDcmzyJ(ovWnzWImCn!6`p2ws3&rj8`l1uhWhByf+ z7(Yh;02=9bG28M2zNN9neEa4GJurPmbXqry^<5k+W>a%&Fg&L@!1g_>&8>jzPwqV` zIR2GB^V$%!ZW$R=4Db$WH=Xx?t{fggUY}1|>6G zRyhnCAlC%x&YQH6-3h{K@ngL6<^~TUmiyg*K~DQnxBx*cqZ}02N9bx%oB*$ro;&7{ zT8TM*x%Q-_Hy-7f8s$I?yStt$S z%5ep{UGi0Nzdru~Yd}k!$uX69>770l_4K z1uthFjDFT#QCz|qi7T~7LPuI@9g+ULVy`XTl#sNmac=Q}lIO7c(uK5?sgaY8gb`Bd zK8&SVbwy9JoB~+>bn<}!UDzJ=VXffu$CV_91CDzBRZ3e`^KfUn0ONzuAI7EAXr)my zQVHmD?b?hV;u*(rRh-P{WD&@A^d}u@hC7#(FjkCb=1k`mHZPeL+srJXNk#5yo1J7M z&V8ekz{6+!`c*m8QI%Oygdi}(5;>)}k5N|t07+<>05~H*g)M_|=E^il3~0wBk_+Q; zsKjC?StX5Cz{ks+56AJRFuYvu+DCn<)P8j%%jL!9yk`myaUN*YMLBMYzTLani~s?q zw6pKps;JB|Pg9R-QLWlIKfEKM0Kn8uui9IV1G5p0p?{yH9Ivo*uH+I)a#JNsZajRQ zKU#PVhG8D!y}9(N-`jGr-y9GkDJK%iwU6ad9~4EnDYOG8s!AA9?B~%3w2yN3$rX>4 zfs>z?fO>VQ8W(oUNzQo~>OQqZYST;eTR<2A$r(GnhZS7j>aa+yEv$IJ`4NaeQKUZsZ@KpeF4uS@ip~Q2SXxECBWTQ*W=Lv4v!k zH}e>Lh{1y}`Wlx`cd*psYm@m>FU=z;L4cu1rd(^$Y0k0DICf#epc%*ET=nhlrF9P2 z<4b#gx-r86iswGdaIPTPCicm~T~x65_?gX95pRVZPNCxoikR%uIL2|7%P}9w zRXsZD^8WpVm&+2V&SeCGeE|NIkp+d-!=oxD7lXkq>CdHJlSaGK_CDrUEBrhFeTT2T zY~xNVm2P9rIXknUf?4L2#T+|HBNE7Y$FAS;rrpV7V5=?6hIvrqYV^-uYn(Uw#fr$z z(yBHA-N+vFw)$n|)F$S4++_o9GmQ7*vi4SYlhD)JUqrPd)NW?gGp7S1Cpv@bsVpT@2(i11qF$a{w591oY+ewCLdi+X-UQrrXYS}DQ% zso5E|B<|Lr`iou8v4HNxXK3qNHc`mYG;b4IE-<|1{{Rt=DuuDO(XQmoxOF6XojAbH z>zbD1#1^)&`H*g&M(7zh`u>!sd1(|>T3X4PD%gx9XiMiIoQ(U`8;46W1;m6GISg`t z$*Pvx)y?jk@>n{_E0D5}PM_!LR@*^n<+r=lZX{@+8*FUERe93ukJrDdb5h;eQI7O^U^$SwTx%eE#hjzV{t*OLHcb zX7WgYODJvI*klq%Zr-0vR#JDB(kWd;=Wp(HIj!W9;&}oGC^!Rf8RzJGVzHqP*epp5 zIX~V102rQcVvWpaCqq)=S52Oo`bg&6#5#$zcl>6eU+UgVBwjSI=fI?)9 zegd$swR@;fp4RCZ#x|aV-m{y;mwstjz+HnZss<`!hLecpUMZcMZkezmG8659G1vOk zk!iACO6cPYv}Jal{`JMj;=M=hXrfmNM%{}LBLnMK8^l`QnQts}nByUpmv0Bq`{Jfp zYO6(Is`S~{$>F;RVe;-7Wku+vcn9fMY;EnVltX1~u!PEjsxaB=fBkjHF1xMV%$D|u zrKG|Jkp>CroYW7i>hr0ErV;HWcEo_=9sR2>tJRj0WxCK`3Oh^9Qr-~JH0bk@%A)`W zoUEm4G8!Y z$32FB3eeHulHsIXk~beGZQS$tcdA-uoqc=;V~tsd&5@Evuj^ikr^O0DuE7K&7V0t2 zp#5tqvr$~AsHWZ7%-%%~n_!PDt|lWau)fiZ;~%H#TxO|pd93OIZTF6t8~O_GHH{kf z=H$tUom_%dk7~|It~8lm(%(#m*@FdXWjS`wrVmO~XUeX%VL0DMqAuumH_<^8-#3v7 z=YUJMu_vF(wWXI!wRLUk#fBqI_}qUQqXpmEE!WMIPUL_VHOK&RM{2!sWp6CYb1kfI zDyCz}Cm8GnaMhD?yuSmg2`Kxed+Bd4t#-t!>iIu=?(>068bpxUMHrKFBJ_77aXCEW zw`#I(3VDXvZV)lU0K^qO+2i%8trjS(Pus58w9#R{U@^x`4u{^MHlv|UCiNq*wYx|- z`z$NF9LV3tPMbNTeDHuFPZ(k+F&V{y=J`MOk7{ijg6 zV>F8{z%W(wx7&`@c6;2Lt&5tM*dVg<{%Icrbe?86A5FuP-m)6dw7y(&yhs!?Wns6F5-R60Fi252=p3XTMWDW>h9n%7dY+q9C2CtG*7 z9N;kw*gu!!N|HyuZLk>1jJD=bIrORKZ!$lgA?5*;H~^JDr{Pdon4f$iE% zynl^Sm%8pIwIh*M<_BU@H(|!p&<{*;*wWbxSRva6{ju}Oz%A}-SGMz2l0`;WasITE zxO)IN{A#>v)7{)A!tq9S2vsnkXZzICx@cC^tmUVbD!*QH}8XP1;jvP zhQQAsUMgE_SU%ERN{XK`P{(Si9+~S*ostrXDJ>38)`_#f+Ky|xBo?x}DJ{Y}lPQs| z$s#qu!h`NQ)a@)W2&6}C#1%}&#I}2pNhRV#6n<1u35f_6Nd`zg3GZ4mi%VF9w*^sx z;5K?3dj54ywQU5oGg3io5m>Fy+9W?SOb8!`pr^(~=#tcBV^qWWXiySJ$@luyg8N6c zQ6pZ?;Xw)z5R7_qd)9FACEJPq#HL^X3PJ>rgZkF7jOD6dd7G40?C9*QUcw0GPa|U% zfT3-;R#FQReJh*S^<6Sc*kX#&uV#%*W<@zdOB2Wa^-;t9q2f8StIr{g1{U7cKnLn; zaM(p}YSBRw+Qx%(kTOwvlbT9AlJ~V><;=9v87bhT)FkuoZ+2lb^=pxH)eSajZvVEIyD8Telj1S0E=?0yBaT$h2MURvc0kt}H=jmC0+0QMt zy`)FWDipi3W0Tw0JXM>E1hmr(QV{N2b1LU2rZGcHWW~(MmfjeyHi-)(9IBDQZs#8L zZsJyLur}Zqk`s&%t!G+8BtfN^25qGD>5<1Yu}wdd<})Bu&>!Ndanvp{^gQy#9{&LJ zc!$b>=Lf&ms_Ie4_I?2w*U`ctzQ>W+bJYOAD|82{{XBimZNtZ@-@Ur?$Qt4 z?j48mdk;#rd!d|c_Hrhr_IPmo^#iqCmPl-!QZnLE)Gs;qrMO?R%bYlA7YuRV>sGGT z3uK09nVF1RLC!+gRHu7f%|~%9r(0$7q-PS4NdRYPH5Hoq@8*r~CgX*Xa5*)hWotQ) z&60C6l>R=$+N;AI-`W;*%WYx?TReR$6(x6LOFaaTNC%eZ496Q(fPej8TCw(Zh7g+x zV51;oimPvlnaDA`ra)gLjCx|VW42q1h0Mh>pOH`NiX|>x!Ybq&&eN)NXAbuL z;|_XxfBkwYJ)}zIXPa;1jMMhBu0{bB4(*Me-%7BIuDt*!p|5E32-)}m6USa@Rh5oT zLmx_LP*{dI#WB=^O5}k+7BU=c$qo%7I_|^pY6zLjXBq8Mk{Ph;jyqBt9wP%UzkqvC z%2Btj7&otKk2p{2Dd(7r2FRu&P+5jg40y<<;3#Eg;CoUh-54RgsU5TPFHYdlFxm?J z?4jw3If=G|mFQ`bIjj zQ9uldPH+kLr9^aWflp%UydTPyBw-jW)_@{840z!BRDd%lKp6fNBLK=+`#LAfI}X6f|W{ z-(#8skhsWY9Y#7(A~B4F_57$-1&Wc=r!@B32;?pg2dyNFhZyVaOaWQ3(~<8;Lb4xR z@k*ef$qkxlZd*C#fERI7w44Lf8fYrO7~0CK9=X6=b@rtrYbe16nU)X9#wqy>PIHk+V_WZIj2@JM93BTFnsaT(L$}Zx zOt9#3zVrbiOv8i9j>e}`A63EUy;Ub}8w2^%iRDPZ2hh_3%JnQpPpwE58$FM=N~*FH zmm7)o^s63XmGnNQfE1%Ewp31I&)dtg^j{O_cpAOL$n5HToMNzd*|MvItARwUc{~3S>Q&)elygkQCT6T zwUn6M(T4}NDMl*(>j_EQ-a{H``@3>5dF@D{*yTXrcRW^_Ypo(IT8*qXag5-w+Ut{^ zqo2;Dw70UqjdsQJ*I>(UQQh`LWu0sKnukUPf`8bo?sS z%Xv`?WRq%1^9-;hLEwUM%|L9YwO5imVKfMK`OU%;)DU?5s}6gKE+=VaY`YwjnuNKT zqkO2+OH@?JXJQw2LjVR3>rvd=NMQS1aG34cilJuCNXB{mYJiY|!Np4)=%4Ep$bb+N zb^s^6X{nZgCS~c5rA#H>FnBdjb~zoX!IYfUkkLB{BVxeteQE15mBT8AG{D4n;~axd zDGZpvD&M6cp&YRU0nl_c4#M0F1N`b;&V+8r{AneSFMc6p@Bgp;+@VgKA_WBjBrTfudO*rBZEK<$p`65vz~^6%Z!|YJq;NR z)qfE{4-$YneQC=f2d+jc615J}@T-!b6S+t@tBoDM*u3*0$j(BcQi$#`l%BsvxKpEZB@aK*H5T;VrZv^80^UbK_WIRPEQ#mV?8SysR=Bgcv|uNsL2f&w(^;3*+xZc>F>Bm44sDsi-kaEkfQ###Bmt zwr^}6Gx*YTOK?zcV=@bw?VLTic+dBdx(eUYwd+`$%GDs<3pm{*U}O&Y9rIC5;9YtE zzFoMNDZlql8w31nI&BA6fPV7E>3iqPJ*zo7RTk!nRi^ekrPK6F>m2D5LFT>y05siw2mo~Sn9l(E?0NMyu3>OQ7&PEM!N^WfBR{}`f9D|HkSEqRH5YP-_4RwmukkvkZ^EHj%uQ4dRqpb+Bq#|mxC&nVl(XB>zUS8 zvrRLhQFpp`I1P72)1kg)j5WMvur^2>C$4jYSu$ud{in*bmOH$5i1Yax?zLYDnGDSf zi;Ii`14*=zo>+o9nxfhsx1_)t*4xf$VhtlkLwQ&{jz0?Nr-=7{Equ;un16e3xZ|#L z=Y}ID7=TD*Wy2`rk~?*(W+`@WRBgVv;=LXV&0ZtsUDydyKyl~7SQG3|K~vg|GX1=% zbXOw)gZutd^vzDTH(_LxX;B!p>xOI;{ice#TuXSd&dQ>ka=Vok7OfA7YU;+LWKV7@BMSV)!v(1FgkAj38 z^UZEpc&hTnBUN>6hbmceSMlpxI*ycDXx1Aef;lBgCxM*t!O#ByuA~0|ge_@4-$E6CODWDc3e z^(3#od3f*)(ZpU&P9)pgVKrjU!@AX(V`r(t4<9140CUHsanz%SmavtMx^-*ENyg`@ z{jEt~n;977V;`?H_PS`%NioTufmb=NH;+~EUX;Rni$QS$f=?iU#&eNfUX$WGO;QAO zo)wtzV=fNden<4KS<#d=TCXFf6=OX%^)+R`xlo}k(7FB+r-AF5nkij}??gbJn-BQ+ zr=+gjWd=HYwAmGi8_3uw!`EB^qv zD?aPR`#6bX3`R!g&+?{}p2W8vr$GwJtUuCbz~gHi{>$e+7>;U!a zQTc91Dyl)p2c>9|Gi{Gml1ULGCoVo*p63FUrfYc&CvVHcV1^$|)GxctErIgmfN_uW zielnJ!jba^9*5WZRajRgmPNrT>;N6O{{TH|AGh4ws`)d_rF|IVKb=RFNaS{y29E?G z9Fluf8nwl>wc8@ywaYNeI-v>=p!TXt?!-5x&YH)^+Qp$U{{W-hZCn!YfLGrmt!mr+ zK!M^%mrRfC1@Lm9h8@V`HRl2Rr`)W>ZomaN{QJ^0_c2{Z5*uQ&=V=5p0iKy1>AEpu zRV0sZxA7j8bf}7!>{&8Fj~jb)=xaVbTTe@km9CFawYAeAwnUEJ zMcAX|S$zl6vTvf(?%(Yf##>0?Bt&Fjcaz^0%G>J_S~ClZ;{)SagQ?G!oTp9*VcMGvAK&Us#>23W~V(wo6F7y9-#1 zy%b~&5sYMhHJhwjTm%zb#APZsNih4M9tZ=iX*`&3FoC~0J4nE+?O$3=9?~=AD?7Hp zG1I^0ii&b>R!dUn8!cHvJu>rE65SzalILhZt&Nf7008ykwxaO#t7_`!aVIKUqV~=` zc&x2A#X5EUv5{mJ@?@cmpO`oG&1^mJ+(zJwoRHl|PAca)McJzv#tG`3%Jb+Sxm$3O zkfW zlby_Y0;}41a#^J;wypCwCu!%`{QK0}Rm`bwme%)o5;8Idl0w7-f&z}+{X17x40D6~ z*=BDo#sED>IXR~~&YpzEmp-O^9v6lP7C*C=ah5N)p#K04w7=OcDwIfNFvEhShCupN zxF)^3icj3l1EU-?k_=#;x%_H-d#U4gMY?B^PbnOSABi1nH&eN4os7w}*_f;a?_4+B)%yhyD^KEKiiq z6AIjPImK-pMJ8hC)JHa+1-pedw$}qYc8~LlqTdd#%*^Ksrz8M`k;(pmes$qd_?y6{c>dlJ$;tFz`VNjcm`I(h;5)j2#f zs(qiz`!axbwmIZuu{}DP^!asIB0gIZ4+=4w%9h$swIruinPFrKA!2cy_56)zcywl- z`rRDWhL`px!D6k3R|-bo$MLOLitT1G;ISm&f1kp&7eYW`e=n> zP=lyD&f(YAu`awe@*+rphjK&Ujt3Yc>(Av%5piR3x;anX#cRd7rOL5kDiOG!LVJ&I zYN30qYc|sdu~ul9jroY=9-QP?XxB;8YXn{(R`WTsCB&(oehm2U6B(B5hy;_BI4B9b=bbjMNBr;;vLiXS^mR&&r^ zH=3KHnnF=V?mM5a)~%bP37Dm}%ze}aROch}HMagAxQB2Gk+1~Ero3{#kY0uCJUQy^g=ioT#@Sby!NGzO2_a zP&qKiGD^(3Xp;|-{VEHMIqeQsCsir83ZU%mk8H3Y<$vKbkPNX!2K4mr=IOmMpVS_7@7#-wuEM$IX{wu}xo7?`m=v!1_&Q@ZgJ z$Rm$WmR;cBfS?CHxTtiE3g#(9NE%rgw(XW)GEN37YfjQFVU9TkoRdmi0K?@>=cgx{ zZk;$g+Tf=tF2^l>cRkui=UM}_ZB=oc`_*XltybgraYV}y$;Ut|wQY7^wwTvPhss96 zyAZ6Tb*ehO?yr3BYN4$YaaWEo3lcrgO4<{eR#8ZaDDK_LQ&{NQEti>fc81|l0>VJd z4}GM+4^)95=2(6G`ifN1=j#JqgD$@Zcvkx=U~!4QtlC>2YxqA3{#ah&_|D)yBV z-3hL4u_R86r3vhPe!SDHygPLej(e>t7~x5#XSffN+1rno@TexgiW&BZid!_9*gCoQ z^*mKh5xt;hruvn&MLNd09e{~rvatc3h{E8n1Nzh#x~vjhG*(Nt7{&qHjNo#A6Vjcj z-^+VvD$DYDt(}ATMlc5+)mqj73NcU@f}`n8Lrq1^sU*nJT*KwZGXz`$-8~L{YHdd4 zjFCo)&2b`tMn3QP{*`4TGqI9cesuezwrXTVQI$KJ9LPuLDj9bnl^%HGh1{$$rq(Od zH5k(6xVa4z1w35={g08wCLM_2#FJC~cvVITXlO1x7ikV$uxz?&CXl4t-nc zPLv5AIT@84wKJWpqO3TstjI~N?TCWf8D!h@VTKz% zxvd!`ySZ;J)=1(TbIOh1om5k)-LZ~H5>4G@;2eGxe%fs|+jKYYv6uzpBn*506i!R7 zukQ%2xPVD=01YWDI-K=1R>z;AcD`Tx=+Rm8Kjr)iUu_u2S0@kwB&^&`qBhDxa&XdLM`cvn>K88$-T}DC zGzd`fk`YMopfhR#9gdQbyHs**O~ z=YvVSm*5V(iZ-!UKcxw`8-P2yVwi#Q4oJtPH0K+X^G?HV`G*FPkIVocOi%!Xk%k~Q zY}3XOu_JNqQIYd!0N~=B=XuEE9R(qhs|7!NXQeqnBQMZ(<26{hWgjjNOp0?i%065- zwJ{SsNLMJt1JE9oUt=agT>cdzHZlfr`O}1?U~+!60S-wSBazmO?p%(!^{X3Uk&gul z-8Ob9^Xxmr1F6~M<{Xc;h_l#RK;9A>1BMSO-E zThgln7Yf4!9x2iN^Skq=1%V8GR}fw73U6(ULgMSEmAiEoYGNNKx=W!Npy(*1U;N+bu2bvx44o0>lqP zS%j$=SHbkAuz#t~2iB#UM`5jtK2mp}(5mDIxh}hEO-7jP&&M{3)xYV0LchJ6%Th)k?)V5i$9Zxkf(YrB5y8 zo%DsSErq+2mV0r*KkoGWu~rrxF7SX^tlNS2ORv||ezcb!9=nd+t{~ZS2>FY`+1fow z>M33~*G4-^+G)p0Wn-*R?=#oPM;?fO^#uUsofJy!16D5?lgGH>Xf) zinDIYnvo_uu)~T4Vt=zpnc-b}@M(ouW94PypB%Vu38}-3{L9Ji4HgYb$L1N`_+pSC zJwX8X6*Hk`%6?$fL8Oh2;yL^%0a#;>x#K3I*m39wBNZ@kPtAgRaZcj^k4i%;;4u56 zu6onFvgwro{xvSt2kY%h7XX#u4#I%B2bMzp)A>>XlYk9eISZWfc&JJ~>=Fxh`cNy8 za83q)!j(=t)5=J%jk~fb4u0-2^`K~S$+raXbH*ynS6OaJ`qf4p9)6rsV2+fTMwgtD zV{(J;I+{neN9H#p*ovSXfWZKYktZvHGChqn#bS1dr{6^&cNG~`$2))@jYuv700}wI zaY*=K$MfQy$g!`W*j!7xdwa!;Z}2HQi0_Uo(zLxdQ-UD#$s?{XxNqz0*1VTad1AR! z87fXW-CmWT>lYG3B29TF&>2B3$@L?@73X6j_dPrtRIz(?%&6HXk{opR;~grr z5^6q4d7ekOmQ%4p1t4_C1Jj?SXeG=S5Jwxz?xz8oLANI!wHvxk5SnR_whqNYTN(Bp zYt3@8=%h0-4Ozc=6qA91rE{cyfkM75GFvAHdr^cc=gPg)ou#@|SiRNtptJ;D);_9SPXzMrNm zHct!qer97Ol#r<#g9$o!Kab~Ey%Ii zRE%yo$6kBWQ=DCs6NDwYGY^BjJXj+Ap=5lNSCDib*v&dGhuTP0D|dCcfWQn6GxVzu zEQTv-Wte@U6k~!0PIHnDa54a?;?x<#Vd6-miy6*$9B1zzPW67)wZ0;Kl`H%uyFDJ> z%_M@>{^gqkaBMy~>6~ZRin|Q3tSpUoS;LhfQ;hoYo^guIhfott!X|`5=L!(uvks>@ z;8ExDAP|8omN-Ij>$s2yp{!lo)X`Zj3)^71i)&rMD0V0oNW%hg)2F>g`W1w;E^Kt! z2i(V&0X%l9Hn#Rj9@gB<`<&#n7bmIiN3C44w~f=xTY`5s&~ruF*^bHXh-@@_ zTX{Ui(^eKFIP#@nzf5P=v(5&2H%I;pc#yit3 zVFk!*_~ngw!Gxg){o(!<=E>swO`B%Yg0@fkxmaVIoK(x=T{W0_Q`}qa$;lz|amO4A z+2Lv<6^W+$o}%{BO(r3`NcP}>ta5noSySn{x(1RBL>DW8mIDL0u46^8)b$&syMpM5 z3SsAw8F%M70B4+f@m-~aZDnM!%|Dp=z;Xy9p2O1^u6e&??48Y^y`sIWVy%VvY+W)I zVSw2K3)dqY)zz~_*dFe36XtM^amUx1wDN-?b_WWi_2lE6kMrqNcT4tmm@6m)bAmg6 zKhmYm$h8E7xw=S*1;|Wo*rNv-?^PqdP9sGq4-7NkIP2&tR{{XF58AjG*H7(5h{{S)W9btE283jOIxi}xrko~IL$ynS5Uz$YU z_eOdjsO?*jS{Y?4ZkyGx(o39VjDK2n-KD*}(3#dU5RyWimi#(#`qg_>v=_6!rdn+# zDHWY0VeH#pGMQQMDt$LGA;p{GqC>vfj@;_Nj4Q0wy^-?<^_MwDo-L-!(0;* zmkK!R>&McPs@AJObkou5WLxRar?zahtJ`va<(Xk1{JK|BVX5CF7`S-lQOTFf+xdaT zQ;IuLa2aAzwR61WkN&@Ug6i{qv&{HKRx1{IvFJWfIO|GP9QO#pLt}0Ag^fJfys;QK z4ZErI_cfm{id3qYEtPS`C1I2JeqW_?<5*=`qmUDD6A*_1uut(3+Oj|r;iZwEa4gLy z0H5>CIMd&lQmNS9xYl(>Rd+8E$(_3f0sjE&b6KwUA~ltSj;(>_oSdIQp1mpYTp2E2 zPqV9`L-Ml@xE%A_{Ay_;X>{mO=8*${%oO1po&{Gmt)RCSaVuEFtg>&M5+q@S106j{ z_7z1eoZLKYS(#TT#c{ajo;^DAR<14;Z_G{eEJP~cf1Ghq-A@!UhlylXpEyFHn2>t? zKf;K&Z&5UY3jq)BaOL)N=oh!+{u!uIfM$`7;Q1_9JdE?tZ2tgCnbqXEj6J|qnf4U} zjF2*_dLBQWK^2tdNmd{+=HXDDNFKa?C-JLKyCtr|h!$x?gf_r{WS$UX`f98L8@jLBWqQ-a6Hq63JBVyoSvL?0)+dC zq6r=GD9@J}PI&G3eLq^YWgc1?nWG^Wdx;wW4s)JA&J84|?N^({!Hp5ZMkHUnI_DjQ zQo6r)FKrB}>d%>`RQu%g0Fl7<6?Sq~MChHy&2Y2b%Qo~e88)Fsz(MRjf~1ioxw(-o z#$$+WUYRHR$MLG~u^~r}P;lijgU&jhM^1ax4(|}|#Edx42iVq%J&13({E6dOkujqZ|U zB96U#*6r-D+c~oHTv)4ugdr~=>P}5zS*JT2QdW)0F7AHQ2)08qyA?4*8QKm;GI-#V z&N~Xvn%vmmeVXdx75PJM-?*P)@0z`;8~f|%%oa-?2xGQDI^1-D|=v4PDtn=)VgCkqUPSv?k#QT7Ha4Cy47dFlIwO=oG;;^>D{=joo zzHhY^Z{9DNv`BbG91gu|Tf4cXRnzQZGDnk%2-*N1dn%UvJxG_Mad1(>GNya$?9lO?( zTg$0He${l)>`;*=;y}+v;A5WntZU9qq~6A~qZF=|=R*dIr|1kXFEt0ak=H945EZ?_ z@7kcf@qw9?S;Mt6ggMI-^yygl_Zo(&_GoS;M6p%cu44f3Iq8x*RqYbrOP1Dk*(cWTrnFzT#cvw`SxRJrP5{TQJJ(Trq}a_2 zPpNrrBC7n%#Z`zMahkUdha4}4SVE7xAsbmwZfeAOPE@;GZY*-Za$AAkxhGjRxpX=s zO|A7g_~NkA_uNAjn2T;+PcLf`j)RUzpzm6C^O;>*D^s>%xXM%vj@jySR+mCezF9XC zhda0K+83Umm0XibwvIUVh$BV8cE;@cRJq++iR)G(v4Tsqg*3&)ct(xzo=O0<&Ql2>GfbCipZ$BM^?O|!Ihjx9*W>_UZ-a>I{cc_yq#j|IqrJF$Yf zMcT!j`?o+dO|3L!r>>=|Yg=nQK2NbLJV}?}CnwdUO$nEoE*YK$e z-8HhL?5QJ+Vl%)#q-LvKym7#-41RpkoxB`lJ#qzO%-b}!g3Wh*BgmdaWG_OG&1cy& zY>gzh@?|Vp1guLt9(NPm{{SkAO)C6cFP9idNXu=1m}jroyilhukUkr29aYs9ERxVp?Nv2&(6zv`KOit0Uo$ahEfIce!j{s>8pzSJs;SQ`dK?b8?Nh#^b8l>7l3CpC7=>Jx#;8FJ^rScKb8&}e zXGHlClx+t-oik6_F>|A=Zy4FRE@GNA`=QAo5$#jOuG|7Z_aBXM*Oybv zZz7nH0By${1X0)V_xGmTLvFTzYnDBO00##QN3UMBaY-wuVr8q;?jrG@odl95N}wb= zMn*>*jydUEACK=YHQ6nvh_PtXYN=n;WBl<&>OvuoB`&*wCv)eIO3P^ASh#CV;00qElga6fS1ASUzM{_4O(RA80h8{i$9jfan2pz$0%h0& zH>V$5)+#gZY3_DAX!V;oFIETya!UCMBjX!+IrQg>uKp!Yw3u4XF)B7Zz59vhJ-Dt! z&v6aVadre~0~l37RzF&&YvBURLopa-7Th?yVyGo%e01k3~~Mx$Sib-j#731 z0KcH-xS=emGs!fJ{2Xo>Bd4uWxw)00Sk(l5!0AtzUd{JCI^yq6oGcG<5LL!9!;`cR z{g$X*=(<(?+_JL|F_^wp#~JTlZcD(*`$LkzFk*A~V9_P~?{y~mE=&;t8lzxt{6{9K zNr}@(qRF6W*LP@eNkmWpZXaranz<&MWXJb##)U@R%7c&dit(0ll0$iT7{}{Oyzx!N&9|7&iy-NbY_jWgtZHDaTa(WVbly7rL1@s;IbGr z^}6#A7Yyp9O=_PT$894;BrL^F(nDlst~ZP96Ks-AFeNw}e@f2O)8=F5sPs5t;0;Is zKe5yEN-NP9#g+v@*(W2^QCIDu++4LgA1_P_e4yr+{>)#ZKjof}By@P~n zt7qDu5IM$2(9@YtLB~$Gq+kyV)O%0@uwCR14I*KV3jQLaEy&L&xT$v#yN7Q|UtQ0og*vC;yRd@uQzSIDK zD{_RX9<-=g8F!JkjD%ph1bWdqQg*jd=|JpE~I+rPr zmWzdmLb&<4^r(n!-D=~u)4|Hq8CALgKwN;xRlTXq;Qi1j`F`#>6&XNJ4UerMjwGoV z9comWm~9|_Ra~qKC}U7 zJ1N>Z2dzgSbHI>&Dlss1$&B$%J6S`F40Xw%LI+RzXn?TbnpMYDWAvstQ6_l7r>cTD z=hA_X4juE+g-m5EoZ#ZB#!20k=z7z^A;C^ZdIG}B5$sBn-jFnbLXn?(kg;~^Fnd#& zC?9>Z+*1)!OpZV}r;+mR8-YE=IkERxb?9k6SleOXw{U0ytk2a+1$xs?U4{Szb*VQn za2xLXcc!q~`BuhzPy=$Lo(N$=?O;%@81gx#Uo4ZjFd$QL^M+Cik9q)1g>tF z#mE@QBOs2{(;vt|U}ypma(5n|%AJd*!94U8DCKwO<{b2(W7UYp4i8F|W&6R?I6bNcW02f@!>tT?1og*J zKo?5H*dc*9;~nWXwhjp+wtH1b_XaJ`BO?`LT&kcL$R?1-`KNf_mCpx`DM&24K;#a& z=}lIRh8UI^=z5BJMUj}!anyI92voLx2=7wGcG2x2h$EbX!Kd=CheNRT=s~8k#=u9M z9ApF5fHYye(&csgWsqTxS~Ikt>H1P!=@8uTTUftsGrTEDY|Lmb4zk_=7rD+B5e z6{TyhP9s<@)h_La9#o`}&vDNO-k$b4KBFW;-OilBaNcVcM(fUciX6Y40*_cSy33+! zNsG81%4R2Y(2dA{;2nq3koZPvEhW0MytTTG2H=su?+E_@bFCVuhG)|4Mbgi2b!=Fu zk_XQ}rDfaQOKL+z&XOx+5y2Ei^DEPk-j35nStEE@t0@F}^{9&!InHaUPZKrZX!Too zuOoAoXHc*BFy^JT&@^pT_F8HWZ6{r~05YG%V;_;Kb$Na@Vtto4z|LkjQ`GbsseIA9 z2Lu}I*Wq>4su~SS%3o59NEDO&HNUroSlwHfG6i5;3V`<{{{SEjXZ5-_w=sWJtNf=V z8Z*(e->)?x!5Cm0(zm!_BkVNj)QLprVT~qvNl1_9V@J#z&f%R(kq*JotJYelBGv-K?14WcuQThWeEYe zR$alO`G!Bqs#WPdq)WrqTg2z~$cG9z^`s2>%u!3g53!HlOru-fVm8$4E0x-U{9Bn~tFHEta@QV11wRgSvWGH#O23C?r- z)Xz-uTao-jx`y3ihT7FQ!#CN}pTiigda6>>mj3`VqKk}m=CRpmcCV|!B+L~cQ@YwM z$FC=MZscaKCx)*YH4?C3GGr^s$2ben4l$bIzu{(TeqQC4BKg3N$N&LWBKVJgBLgJ9 zRBMJOVEKsa#d*@hR=v_a7~&|}&7EzxhptgPuiuE98-$Fdh7TCQ01wZlXq^ICyu^^E z)?K3r2poI&t};Ixc#`s5*;~r!6mMY|+NZBmz&zHF@gBEu$fDxH-0d5dTb0~?fpdz+ zbZXyISk%D<^JUn z7b9usBA(hMzU2y9G({m7Xuu!Ry!`6EILt%ra~Q;=g-nuo>DM?F9M_&V#^Gspqo_D1 zj9`k>>hk_&_ml18{IBjk8~ZLLlOYjQ4CHku6o*Q;dA#Shj1mYW9)pk0yvlq302;!| z&lTF0O~fcCk5i8P)DNuqyd*|gFG`MAD8o7R_55ipB;Kk^?+>iSY0CcN*1o{07yv|> zJxccWq=QaaPz6K?1{7l$=ku>7{?hS*Ew%9x*5tEpK)LNgRSt){m+* zwVM0EVpDoWo~CRBsy8yO&WZH6nm#uIXUK{ac?aICN+uB6A zJjuC^M>rYlitF_K7TZqCHf|@}KY2SBW%e2ASX7K*_OIw|2}*xv-k~>z^jnABEvybm z#^D&}@~RN{GeEVv`%HElnRo%oWzTL6Z@ie?#N~RDcmknGSSs+V7+mv?IPY0|dX}c!5xG38 z0?aEb*s_{H%FQT*@^VXzb?=INP#0D%?&`xnU)=+qf~Q+(5=LUK?mxYd2h%kvbB9w1 zJG*V_DY-DPmUiS})CE9E3ygj|(%&0o8I*a7Mm)S@aqK9;o-m~BBL^7=7^?3op&nFE zEQPSS;AhmDN=>k9KzXhwL4+`(@=`BOc+ag+cvCXxHxoC_^8M5uhacy?KJw->BSCd? zj7cB5PT3r0smrLM+<8%;-5YXMvR8mH$FJ#H#{CTCV$w<#$XvjHe8i2Vo6r;2zDTOC zeyq(M!X#z*RUq&P9Fz2_*9mhZ<@~{vT9*lWR8e%{97D8C-GOrvRGGYqXhQDkMpQ?+m`azglGa4xe*z6Np)xIW5TD$3gG) ztG7Br&WRih$mpdMH%`6BU;hAAX&FK`A*sm7HzIKE%*{SP&f}BM>(~m>j>=i!Xr&m8 zzV%O59DXPCr`qT+H<(sO8`ODn$U=u<*bmOPq7hj^7?*p=DDvYNCw?=N?Nd^`c7WkY z?;^Fnp9BSGahDO}U;`xmd-WsmsPzT%*f}}!vmwa&c)=^*(-nSumW{`p(L|tc0p!OX zy(<8T=b08+S(b6Qags-`t~scMVNTc%?%mX2S=L3)DPmc`?K(3}p!#lFBdyby@t#8!KWJhGNsA<|b zB3z^QH{ii*xUm1*CY-FHW^#}CIPxcl3n||u=V{j_|y|# zHOO+gbz**CerGx3C-SRFlGzkfpR&!CU}unTl@H(P#%jp&BaUec$ope29C+Lb=sNeR zSd*R0vCwB~=OZWPKaK?~s~?#ooUmCxO#cA&>fCNc>?M?sHMZ-9kyNR9I}keOKZRBD z{IadI;fD*J{g363&a`crMeH`}HwVFF3xEMXcRx&iRaHs9)Se@9i@ky?EO-h)?fF%6 zS-!-zq9LCmH*zqYJM|)=NfK%IKH#Alj?2?v`Qk_0z(zUbjx+5})Erq`MF3!KCUu#D zMz{m6Jw__z)^3*KNmX7jz?R%M5KkNqbDEM(F~8B~)NdnIi8mPXKvDRPNfiC0Z*b&x zv6T&rO?<^8`%TiXm;;>dJ^RwMcTK5?A!)+QKY9rWymCPNjaWiw)Z|FQq%1NvNw^QC zYbKuedeM>z?p3<3EEJpki1&|2skU8kD5t;Xpt212x?jAuOn>sm=}+FUDZrrcRY zW{aKDp)zFiT-7mL%a$MT4WWm#ypCr>@U88(rM(>6sE_A%0eS6#lb+nu?Q~1IJmk7J z6Be82nYaWmU~qW%t&7`f-(|>(O;O0s*v7?As2ysSm170Qp)JJesoN-QY%>Kxo;c?u z1N^HcR&usdym z_Ku~vN2!&kcv|(%vriPP95GT*Y(Rav{c3BU2XYdkS=tnHDcER1Bl#kR;uIN*#KRR|QHIv6{XW@^`H9qZ}Q)1IHe? z=Y!I$UD(AHs>$ZE#-J}5AryBU6G$}(A#IY#tbl+PGrfuRCy#28ovtmGIHr;{$t=<~ zPe0ul{;O4D50%O4{Z{0R$p7KPW6f$o*?&DMM))xT$nFC?fGrj|_z# z>f*r3v16YB_I5jtK&{&wpSP~r^&LXopx##DR2Ao@K;(ZzTAJnc)x1TZk9?&L*Le2~ z{{S)g3ZbXk>QdVlypXKKa$-^$LFd2WPIYYAA>Pg$ib4f5FZRi=~ zU^b#)?G%)x^ahZI%WP!%!wN82xir9ISewWZ&pHf{4qNf3U0%fmYbD*Z%n89zg^qrL zm98LI{M$v4Zsm3;T>694^`bQIs}qvwShuy2-W!=A+c4^O=N`NsnW*(4_KRO5%aUxL znGv>;^fgx4+)d^gwl+BcFaFRwA z-BjU`q73=}0DF^G&_x?G-cc+vK5|z-N|4CgjBJwN{Ksj>^Qci`W!)nF@qyTbmLvV+ zS-Cbu(P2i(&YZX6^l zGrsT(yi2nm;aQI3?i=?mP85O84mN-Fs*%*ATTEG`a%bg{nCuFBpHeC6<~U^%LpmM7 zJjVg|{{Z!<`#fx{o=jpXK2VYYwENYl>!~hJp^T7fdR2_lL%Q%V;RBqx=clm#w6@k0 zUg@_Fd{*A#=nb(W@7e}`D&3X#kF(_o0C`|LFCKtaY?qB_iw(Lga{x2u0^|?Qx?=9M zT9`FvWLs#-;rSYSiQ$qt4g{0uu zGb%hgSA`*Q)A6h;rg+fI(F2tP7I3)w4z(Oi*o|IYvPi_DuU?&gm8+(tuW}UZ%?)Dm z;WkG*G_#&nQ2@aAHC`Ccn+hYuWo^d+fh+5u^V+CgY69v=;kLV&x{sTDS;jk7-K~^y z+f6mGh)h!+W)4GreLB*Ax~7J``4ulLk~fi7;T@A3MleA1%|623)-ua;CdmlM3-fdD zS+>z?Q{POJ&XW02`G>xKwXqZz7qQ7L-J-xi1xOe#-m;Zem76LtP2C}la+5@MnG<0= zjstpU)|l}Nm(ksp_x z%)2@h-|BN$B(c-sxm&x728KWn1CCF8R9Dma7V*h$c7T5A&f?yl^qpq*+!Z@+W*tt- z!CDDfhCvIldVOlrO$l5^ip%BTWSpMeD>_dqarT)lV)M6S%Q6mm^rv5|tQ$;HEQ|uF zL-MX_o!x}ACz9+Wh>=<*RAx`&r+Ti|ZKPVj%Wgi>M^+if(yY&Os(+)r(IR95FrygHQ&%ZQ$}wLu5_i0r zw2d3vBRt58Kq|cpQX)x}F%r=LcOJsCZdElXx4JwG5S2S{j89BeaRmBx#hs1Hds zWEsgn;Zm;pm1K>hCdj<_;bJ-hz=COKfPI)V1QHX#?rRna?&7(5?^iX^*pO7gczknf_7> z2=mDm1?A)41xppf7Ws=G)}J!HiRI9%H;5p#lVtWT9D|+1pRH_IPH&J)3{0uC=Wy-o zQORmyDA&KeIKXY2zYNspRBbvf?u?AQp+(!rf6|(*7Oaq+H@joj+ThP1d^&(}x340i zjWz|#VTb&)4bFW}ps3fxFkTEo?HFxf|=Q*4KfTnBVa$EG+gSEvdVnDvBsDoSe#Rt7wqxJ3JBo` zB<{~Y<5`nWs9M^GwoTGV+=&-(Z>an^sE54DdJ;w^n$zt&C6Hh|YFBRIQZ=a|8aPlE zVZqJ?IvX3mvYVOZFXlJOibx7RohsnBGlC%CsKCWkq?W{}zNRepAL%L#XjC>xAH;pD zM&%kribav35UvC$*v}m)Ud!y(;#o=a6lWRa8j?LWDI*fy6Xte8a1Yj{)mx1~&xXh> zo@K)?%sx<{{G|KT?Xl*K8Wbp)3IXMx`c|A)F%C&zkYPeLe;TYU{D85U4+NZn)9Xpq z<{E{I!UiB8v%la46;xf^0fBg+4&H4QmZj);ugp0Z0+Ey!-U#NJMh*{pU7J@u4SiAJ ziu^D+?MOaj#~7tjjntkg2?StdV9*2byM}!z0y0Zv^VXvqkc^(AH1L3o?iuYsgu<&8 z&rwmFsOgNJwIV7LwTT9tKxH6-kwC^Dp9h2QPHcq@kJh0oQ2LJ5GB9N5J;eY#6_Gw< z1C9+v$!wLUqZUHDev}|w5ub0R044{RG0hRh^S7lnM%B(vYFOkXV4RF}q%d?K@q_71 z1+nfa>PKc^bJC>3?fu~SsfdLN$Z&W)ss~N1bInQR`Ezh`I@A2f*pOF}I?@>d*cYZv z2XB{^;M9RfJAfe7cPBf2DKG$k8gOzB1u<7Wc&T=czbMTE9<0NjwK~4wK?5~d0uKxI zsRNvRtIvE;BEpE9Dj%G12&mZ}F_OQPLfcG(ISp3hbF&BLrUid9=gB=qD-)cdsah3t zk=M}FGDPY!qlyCJ?qIn+yVTqFAU}9i0k+4qj=iW>DmczMVvrVb=8R)2jt_bQF#sQ! zudP;&XF<^7o_ITh93Irbl=cjx8SZJU7bKsRk3tS5sZwA4miiJY5+~l2;e?? z;8bJNjAyoKpDT218e(H4PymZQ4l1N?JDsij{126aEOK+1UIIby)~ z6fgjlVnOU`!zkeGClnRlK5P~3#TFIH_&Ews&DfJjtG94CB#N`;DLDfe_u`t0rCTag zWAA2=$QOjmXLdL_sS%wh+Re$2IvJ;EL4C1>&|Lna6{mOnm`QcKjYa8?8j0NUwKN zqN%sKHY0l>rf3MD=Ao2R}zId9CZvj{uSldsX2U6vpp&>j90rWqRG>x zl_6!hHt+KQJx|jZ>62Aw)34)`d~VXY0Roo+bLw&b0M@2lYYeh6x44QC^6f6?a2}*% zq2{6f*Yj2G7Uo|mPnIQR4!Q0IJN;{!DIE=>%#mEYJEXU`XCNybrAr>*9&kPC1-QBj z>oDO$g^AYyFy|wo=qhun$ri;~3rgT+N}b7`c^$r$GHN=4S_vkH_oV*-tI6PZ{{R|# zhJ|(21h62IXyK5Z+eAeDIP7ys+il9oP#GkAhug{T&mYefWNJ+#$09(XWlhAD$^QTv zWS7>lmAszK5zbRSS3iz2aeygZ?1y1~+Z0iv$X%TB6b2`^UMU8l45~;;g0IYRZb#Rs z{RgE_4z45~WH7vO?eiFfz+v?wqq)|ic*`s71n@x{zO-rsBh+AER7mkMxA8*2k4&DN z)wqf)1rx46g+M2t&lE1PZeub#0IS0^ia^KI@lrM1FBa!Pv##uZBc)3z4MN46&YJ^2 zbyY|nnK{mB?e=Z^1hSHFN!$lLf%NH6CBz^G$X{mQdUQXHNEr@LHj)% zt`0#FhduDEj%l%^P`=@(v1Z2SJpQ!AP+tZ>4jCV%uiq6VUC(OykB&w8l84D=$;Ad>8_W%B_3nXb^oZmbze9;eco6n4eg*??`` zFmqU}MOCzo-3o7XW!ZRBOtpk0VsNX#`LkLOY4(vil#R~elJaDqr7ZJD3G*P1DOGdk zNbGn6^QVi5f-6W!$5Ov^3eC<<>dH}y*%A;HH>^No_&}uEV;salJqACeR{LTkh_RWA z72U}BasGQ!#cPpDU!-0{KJ@e~R%sUo*xd94ar(E@^JeN_sEKWE$s&8#@8_Y7yue5{n zfIhhIQetBgGTjW0$0CiupU8gWEOK=VF~K}GdS|!kP`#YH1MI_)GU@<7fW;qR zl&O7+6bAWsV;%B+O-_TCQ9L)~EiCj zB3L5Ka)LI05XU)edwbNP86y$6kjSXva7a?bj;HkEt+j;Fz}uExt{BLmZe}Mu0y}d~ zjspaFhRs-jHlw!E$KQ@H4P`2cvXmIx7_)AMUEAY!A9tot83)+a=>(|^O0q%b2?;Ad zb?=OQY4FCD_T|!zCF4aXIse$k}{+!xye|-efLTPWqgfww1%o;&<~7H$G2JnEW`WM`|X#2>$@P zNShxp%O07?9nTfnN1>0jtkMF_fTVD8KAi_jR??aw^1RXc&#_8ITWHTG&>wSA^_Q|M z*mpRXAuD}+>d{PN`J)Vl6?4Zw{c0A~R6_E`C%Bhzf(Qcuq@KC;#dj;=&|zp=;lelH zasxD+@y|R8vYK_Zxc$yWH~Wq%xTL&PyE2LT<8#ofHNtR5DbzkbV{C>Z0OgRMyp zjT7x~;k=ayx%svy_m3R=3hlyMNUdzmBjbi<%MYRHp1mp3i#}oV6=h%n0CEOKI6vo_ zmxz}_l^FFn>wOwh^E}b36n&5+k&rul*aN3LRI+$+uTn^4K4M2ES1YkyxIBhABD&T= z6~^eqhj8R851Y_?Rj?%@GHvs_j0Ml?I#m04-sARBwx=-$i(uCtRLmOX6KU9oN=}+gNU-nE8sa1JX4;Fg<7soaDYTG3W+x zD=E24a^jNM&%4s+xRe_!xUI&}8!?7rMIz|XkjW>ORAXwe3!HPw2PU;)g3$v$@i}$` zi~w zG^NWk1qWbk9ChRAT9Dh@*@p6M6`76)mlhOzoStZrq{Lro@=Q)}3MU};?^ktg5f*(} zP7$cAQYo^97;?KL+C7gyO0D*2ZmwdUPqN%kmQ(;Xayk3i!ThUmPQ{%SM2Z*yy9m$J z^r@hnEZZZ3G$BqEdI~J}*d4YrEHr;E8Ks)m)*xFYZP#(Z?~_#SH0c=@1+*!Ffynjt zuDM!CAQ6`Xo&v8J6;53>B$p=fiyjIF+CQyn9X2z1?sAKz$!svtxpV%`MNbWd)Tb`q zRAa9k*F`p%@gR6*lQ`v0SPH?N?k#40_a);v+!+1Q?TT`owgnZrVhFA6(n1K5UW?BM z=~BgW=7u>*936}~AzRb=RyW!%SfIDOh80ey1hM}BAIg?tt9hYW1Gnf-bDnC{ zR_0voEV*0;nlb=fjt4o-Hwz+Eu3TwioxG_clt&X5Eh*d2bJsYl5xT`Ilt|h(0fe9t zk6h-frIEC{{p`>b$IZEZbM<0*rY+sA?a$fJMC=ajh}-k-anhlu(7X2r)nU4kn$%4+ zYP(x*6fQgSio0T}>a$6H(l`WTc0lwT3TK>m{hdn&Jbl7A^c|{5(nZ=Cq*q`GK_}j& z)Ljd);|^Y3@+kKKew9T^A=`a*xbgrB0`&apx`yFz<&i95+l_}US@YUknPFL_m09`_ zoRRo(S|+Wj4L*j1jL+qpY1tQW8)AqYk9_v3n#0_}@!Y{AB!>BfnBjfB>DF>b6vp1n z+)Eh#_dtC=`qe!8b+oauo=bpv!kIro=~H#haoO0-v(#4h2A<;EY6FDYo68TUTDl2o zSjqAbG3B!DUB1;)3s|G_%yFI2f&$5qa7pjpq?%nxL3l00$B*@ME(jff`uot*Z`~4Y zElVjg#5~Dag0~2)au@K$M{{t-M2(3VAnuTjhx*kRp5w|T;SiGFI;bCqZ$Vgh)80WO zl1Q?7j`@y9Acb7?#y`TY6x((tQ?j|x-s>w2ij6Sc{mdVm>COk%vaPRgOxG7|%JC1n zqD-j#`_^`!rQPRqA{O&99KJG7sH;L-^C7kqA|i|~#l(*p-Mx|$qbINj`PJyO=_id~zMMOdF_Dj4k&2y~ z#@=yQn)0UB(x8NSsV3KTF>q!33^N3Zg$OQ={&2wyrGE!#O~V7s~cW`|mBXoRUn zbvZxm$u%jO2PRZp7IsjIt)AaZRrb*s%(BHNmWm4Qat?9aV!D(T(ISLPSfeBFqa2Y? zz5T0B(R|Fy$(0Dk2W}7atllDTV*QkQn19&I93LcpXyk6*GXDUNPtv7^$Xr7l4FpfM zuod#7ABAi|sYETeh~#XZ3x)px>vr!^%X3Tl}(ScF;_Ul;RhnvAWr$Yy!q*}*CmvVG}EHVN3zzLc%8C3GdGr|0-IkkIBS57?Zo{sK>93P;-t)mBJ?wPqRF|RH`i!2yfvFc3m76*j5g!7GR;v*tbLv* zx)6j?-#3(mx8e;8ol5BgC4*0QjezhHqv~nSp=T(kDzhj^b z-h}t!r6*?C-L?`{h8Oda(K1HF$;kG{CY$zgaW|9Y%KJym88R24CP1FAXt=5~f0v5Ub@}%*IEp7V#?6J;0F-?N+PmV{vX<}t31-!kd zAI_`+yyn*Buj>9 zw;~gd-a(Q0(&qajw^IuO^?ub1zDg;{M?GpeY$m;Ml3dBLmw@9VA5mN1*p~Me>bDCd zV4s+v`AHwrp4vsUMmWXzR9tOT>ycEdDD1@G-sd|Fg`Sk@3^v|;t@qi78LJmBq5wDGT@A4lj~Tr=`5y5;kt+BnHR zC5NXpokZn%Fi>e(9Jrq5R*EPgF(4rCbJSNuC)zg&n&B{uwE#R5QF#_|+(^@#i4g%F zV<-qeT2Pu@57Rzf`qE{a=Rpk3~{V7UOwt%B6>T}7c$|IA` zji+*W1~PMx!ml-)Hx1^><}Wb@0~`_g)ycG-VWaZWCB6a@=YUPa&w%3y}bpb2*=;NyxuZM@?i zw9r8%hvaFiAvsp*+K>`#44gK8ovKBJ{IVEiR7mDL?i^#NsRXUFDszfpCe56YoC<-I zG0KkpD%?(8&hgi;6xkw-Nx4Y_&`AB=@HUCxR-3P4c$g+~d7UMh^y{2iK)c2q+GC zphF~P3JK3O95OhN9oZe~Lm`Y~u6<~ZK_haYW|JBo%?plrBBEokfI!DkMMzY498$bt zlnitf3}87sv&W??5HK^=n6Z#}Vf3Wf&%@9Km5>G7)|v-DDZuxt$lF_-nw0(S4n-lB z3kE!|G@eVU?%{{HrY2OJHgnpgSxHY!br`B8kq!v?F-ojs9SwTkB%&u;Y7h8uE6)}Fb*-29F)NJij6Am^OWGAB~JdLE*b;Q(xB)Ean48Qh?Z zbBbs}4m)+A1_vz6m;p~CH05BgwZA$UK5Q`C=}1(Kt?z?C3oCBH?mt>U+qeXRDP#dz zayZ2_s8Sp^%4h;W*%&KF8%{cd(v1HA5|fiUvv;V;%890F2<&IN8Gv zI}j=7BLI`nLqHNKE!U55C=xOfHxr(D=xIJ+PbQhX6OsiWEuoFNuvR|wyI3<6ZhiR` zTji4k@WO`P8?OL*(-AYtDt-9){#2fDCmV5}YGPa*VbtfPIf}6g2?x|rF$9}QDoaih5*~2h?<@2VwG- z-SiyL7cBjlGw$36ryXggIWj`vieS3h#AN<8AeWK`4?VF!T!6s9at=L(Cc*|e1ori- zA%-)!f`3X5&@x|f6a~mqR)q%4ks+ z!jLyNe&aP_2Qs)$923z<=jocy^3-Kj&jWx|=A5?fi`1U|X%6P#(-J_Y8JlzPgJB%! zp(eV`Cra^VmAG20WpnSWEQT}aZP-HVXR8~#7j+O@1@y?8vqEDWyL+L<5@oM#o}PU-Dq z(}kay<+4!HNcQ89Fo;eM+`k6hK{mgCIwYasg51pQ{{Sq) z=Z@rq)2&@w7>t{@XK3Yf#ycDe9v#ssRv|_SU^yR$dR)U%DhQ)Z?IZ(=AdK{NlP3)Pf$PDd z?W2hptfzs{4nHo{el{vM2@9)W?qm09f)@mkivEC{ezcn!MKIHY9D$HV%lAsZg|%q6V=TU#`hK*A-d5^VkTM7zc1eE@LFH5)P!2bDv>CMBzkD9_8t@p47EPT{1NcNn+Ss=Yo2EG|3o9eppd}IT-Kn z$m?1H7L73J@{H{qpU$J+!CP!Gj^v!EqR*(VLlkYe9J+@GDlkbsyHuePL(#)`T=P#i zihvm+0QAm5=h)S8BhCP5Bv`|L7~p;&(AuzSFxdjYZf%)4%be%x4JnNjtA;yU3Nw}; zmu|ITuFNH3NMk%_EcgJ^KrFx8RPJ>Nc7LjUpnw|L_n*>>D+So?(YFladN)AbKMYfs zPKHHjq_%wh~#|2R19-PumAZfAox>cM| z`Bv6z5|8eGUs_ROT(`==IqSzx-{e#$QoFfr@in}VmfAxh3<&n`R^hnR+DDE=g%ki( z??3%&8cp4TZ6h{c4BCGj_kfn%e7l3swkfvyOffi)-^^K95?)qkBignkyOCpHvaFBY zW9J^dYLu7PY6q8S&KbXW%)v_i2YOO>b_A`cOQT*g5fsst34mD+LHzntAkgj_7}4&x zls_{~9&&NmXQpY1sNczU65b-Qvi#C{m>~NO^<+(O5uBMOb#6h7AzXTAtqH{~g3|6U z_C@N$81tfL&p$6euX>p2YRj@yBa*l{J9+#lj_ON=R%0Z64&30HbKD5BJ0$t+$i73tYwk+C^4tsLKe8#**&9LV2aP)*zYPzk0F8xOO80K9xZ0))x)7 z(1&F>W+!gkeQ0**3(UU^k;q;Zl0P|lbzEkqjyTIJG@*IH83g?^Sx{Zu8>w1LmEKMU z*>{8abf#(-Wg?Hu)GcFXY&V*62cRDGmg8ot$Fo1_2%)$eMV7HE##j=4DNMc+X?8&?-aRGgopVxU>nm`ev@3FMvMpS^Qac)Hy# z7T(iKc9b>-*!}v}gnlrywz+h>Ww&B77t6^9@D!cXSL!ZknuhXu;~BOiAmFwIOS0&% z%45JeD$DIycYZU|?8*}{b(59yhDiG7rAuS2+UkhPx3e=A+EdBt^{a7}uVChm*EPP& zJK?;*sg6*$0R9yW(p%e~GWzle*P>%1pT~+J(x9`{uImTIZpif*wHx z=jqm=^5F!#$nl{dm6tfk_U%qcZbKtSG%Bnz?%5~l$>NLOaaep;5=fY71Z0fnc?chs zE|(lu-eQ?7#^xsw?!j+N=lWFB+q$%Wyor~c?900&*oq$B0SMh75#*iO#yj<--G^fK zVV5$tIOHw?+G=7g=1>_^AmseG&1AtEO53BkW>7MGnKvo=`qkBNVkoQ`e(CveN8wFL zp>m<0+0jWONRsVi*A2&7bJ_s)k}N% z+G3(R!m2U3mui#vQ%|`q7e<$G`@eaEpS&BN~pbNM`|; zIpl%${{Z#V;`5mth%^5C= z+VNM+lH%OwqbLLqe$`G38EsN&XIps?;DZ_x--xN+-!OM4s+CfC&$UP_9h^!P;XGiV z1dqa>Hi2zSy9=1)jLE3!-cC*c&U5wj{Od?V;q`n7P)HYdUPfx0S_n@A&WxU$K5~8P z6Qs`QfxoYrA=HMbR?3_8{I+L&rw){5xNk#IK^8<7Lk7L$|=Zgt`R`V z{BcaT^CDJI7BwgDd6{pTb<}pHpZ<8JGHMAet}bE;B1)^fB!iA|?NCLhkan^u^CT8E zrPDOlj{+d0IUeS+W7En>BzH+{;4$*ToUk3K=Gx(;Xj)yW%Y(jLx3L2?PCHqwk)w|0 z;F8(gTp!mapEjF{#4a^>=4hhQBY1LfOo2(Q2(*=%V{4erzD72zqly?v2bl5`CJqF@ zDIb+&U0B}Tpfb%&s)4}bt3}}@jhwclBW}l42l>=? z_E$}0A(v6Pb;sRM6Z(HzXj_dsU9rbJ$&43vB$4#1bu6@G@^?kY@Z2)|t9dG_=WyBp zsNceo2!cm@B8=o6xyh$7O@zrC=NKwkkM*kdw`r#CjwHAtj&Xv(9CRL)pSERtG*2Id ztbxl;T;z~kcc+gJT1Y|jmOudjZsL;i=H=NX^4#;sY<+3cYC46vMTXib0}q(13@_G? zZ6+SgB53?RGlEzydMUuDCh+yJmohj9Im;a8gw*bz&VpuGWCQQU`78JlR#REEShvp6 z?NfsLvP~Y+!ODtX@Qp<)IgaV@PUc3*ABSp_`vyXClUp={fJ|A%X$^YBCIhBVO~s~7$tUowyUi-qpqN}t6U;v`PEIJ(d@ZI~?76Z9Z%rD?Yo zrrJ3eLfo{B$2lEqAozYr=Ru}j!m0*C$Z%_;mcgDsAuro-;~-_T@BTHDcV&EHhY=x`*Xk!qacHh^p1ylC%;iju#i4l zaYDGX9Tpkgw%Milx}1Y$g?ZoP=9g0|3m8h@791QNo4AV$EzQb$AWNrh${b5n?h zN!mv}MLnV2f;cPQfn0%zAdQ$f4ZDZEPN;jPGwV_f-2#F!-k22? zhCp<~4u+Q*V9T7kUBZ(!oo)Xvq!0ogTa4Wd6 zu+w3*A7_tnbMl#U$33ebM$>L>M%3Do@st3Z{x#A^ZMYRxJdA(=72x73US8`x$`G`5 z9povMe9#UCc+N9K%7s)FeW3EF+>=&YPnTe3g_O2F<6xi0hK5887T!lc=aau_A6i_j zIgw5U49)w7R4x2W4h2ghNrrXWLG?VXX*HUs%Nw9<{{RyI03${q3U;7rGxKE7;QE4* zoy&|fq0a{ckF6{#D*UmX+;hf3`c%eE+n4ts5z80B6&#YoZqbHxXFuHBMI58K42w4g zA1Fw_d03DINw(mSrH~=(*Eym~#SegyoQ&?r{{UMRAKR^6e|IVtW&80kBk>eicO->d zdk1y|;rINHabYML0X zo8Q=K%iz z_33iS^dB@=QAM(y#O^sgScb>pPY)yjENF4ilnOEIMKIYqTx1tnHuMa6KTP77Eec$T zC4xgS19z5A)9;Ry{p2kejKP2+BxmiOKQmGnF9R&w0qS_@DneAqqvus0eKzCy)Ncr7 z6Aw56{2RFZeQ6<%4E{lkeZnvgZ>SX?UoQedkHAx-l&}h|kPk)}H7batQ@z3w&q!^FpX3Eub~{cc&Qmzq_kHt6ELiT*i64dZ z_p}fsZwOW_b`lOxCaSlDEk&Q%fKtT&0IiWroPIT`)6NM;mPX0zk+!Tr5u@Y;iFa{JHQucQ09L@AGrH4~-w%Q1zkFM!S z41GZuH8riKpl4^flGUwOq+t$EzI|&;&V@puWKcSBR9gQ4$hK)Big}ZEJ@Mrs`Ac2C=mWH0z7Nm$tJr z%ku*sv8{SU<+D9)dDdVmMSW6p05PLb3 z88~g_uzQSD@hn$9TU=PkryPe|oSyu2q@Kz!>IzB}pP6H9EJuSPjg!|x-$N4o<8@TQuNtVV~<2X5DHjl%% zT4P-}mwN}-f;)&DG08;2aZyJ!O6C`qdx-}O$Bn;$#Zdcw zw6_dHpD(WG$Xxnk@T(|%#a3;iGH?Q&z?yA|3h!uEFp#{h7Jl=5$@sD6rfbL=CEFTE z&NK2iKY^%(0iS1{$q`e9RXNAjp)g#!kaaJcrHzQ%(I9S15CQh6qrQzFY?Fzy$DttO9R?~liAI`Xyt9^711BSX ze;nqiBDAwbHLa!0FqFa$0*`!krb(~;uM432Jct-^i4^Djb4`-^QRy2e-vNO*{A#GP zl4(@k7+F)J?I7p##Y;Vx+81-QQZkW(%hILDX$>0x0GSkITRZP;4>^WMZ1)(c*8C(( zEKwN7aCdY0Vyj7JRi06B&PW5v&I0?Ws>uto$oBKy2~KjHE)U~P$uLQpKiVk79HTMk zb2mSgXU(ZyndjQEc`=Ny?*i}q`eKz{V8i_$S!Bl3^RC>}o)(Vf8fc;n=PkG8BOau6 zqfVmKk4n4Lr;pETDB3W7UouSlrqOk;kU&)1zfHdf)07) z(km5=mU!htIr+iIr8h3f5)y0g-Z+76W$0A$bNGO9QbnjKm0|NX$mbqjdJ#}sk1q-> z%7M-Z>+g}pJNq^{1d~H7(Uv)2TYf((hi!peTcfB*?JRP@h`bQXzaI5k&U?8cBI58% z^I!`$Ipca+nmrfJtRnWDy6{y5)b&+q)37}Op`3d zc`Drppse`rEpM5jg;gYs^2Xd1{LN~$AePQ!YKBL+YmYUzEMmn z!k^xi7#~ASH%(>)e=MMkDOA9wi|7;y9hw!v`}|b7bsdH^z=kj+xmJ-!@sbTGnnAj8 zvEd7nySb?&pH0+%dm<&q%;RAMVyqeT*hlXI+ki3^)B#B?6^C;zb&Ez^M;>M8E4z{D zQN{N5g`!J|8KIrQ;O@@R??~E)l`}*VIK*R}!-Gw8 zsa*;3wPs}5Xv=H47CA4tz-JgE=~wM+b!Bfd2%v->cDcy|@T-z)HrB@iCkjS)u{ad* zsV3dtVtm{$%n1D`a+`OsB@|;_=$eM1cE){8AwWLtLuo&qXu}P)t%}>rauuptG|vG(}8`$2*aB<26+@ zRfhSbS!QKXkcT7#@0!v?T5fWO4gcRFh;Rl%NnV{0B1j1 z74NudZH!wD3rmVX86=t2j#zrt`EBeZc;edYk`+K5KN`0jD=LIbi8qshjw?U}vx^e3 z+^4H|s&kd^aVV=;&V#~HN&~!;9C8WcJXDKeaSW0Ha26%tbCN2yuj6BDZ6JY3+S>`o z12qknu)4LNc;6C^UjwJ5T;ozv=6evFBJ7PMv4%3z2Vo<1!9SR%HS|YdW1R3wyJ6n2x#D2>7STNvqz#?pJ0%$COWyTXc2@TBlS9V*Px$1FPxpDDr0 z`+C-LTBKQ7CEUygMh_hS0QIWI7Ik%kblQjR<2bF9EKe~;JvPnVq!KeZClvtj<)hp? z$i=dwAoLjKt->b_@`c20^D!J6oo*6oB}K}Gz-;rJ_o}>?P_kz`smEs&PZU7LP~}c* zmbsj$8EwG#?rW{_0gLS0c5fpia23GaIf$OXbj?i|b4i)im60iu5=kz9Ix7k8!FE1b zpm!@AV{l)7DoEw|j&pf%Lc3c3Y1Ju+0%IroPidi9*Mh7B+3}h!eW83I+)}fQ` z@|@M5-eYM1p0uw6x6P570_7n8047PL6MVft8ky{!qs~TsyVNGeW7DU-D-@a<2;}6` z*M8HJkUc6$>}B@+>U6U!oVtTWfwYRkMOFEM>(-aejfdSoTAbSCbAoC#vSX4?(b!WJ z(4a0dwC~-g@l>mAwK-sZl-7ghRcjiivdpbATD*&jA4 zLk8{%>D*P8Zk^yHEV$;%V%OhgDwoCG84 zDnStgg&$8^b2_m7*)-*K3zFQ51~10?&3h)W?S<>S{h<&+P+rykT?EIVYG z$l!WW<+1zCfkCi?1au(HUYWtg@GbJDIK0EClu#J*Bz1m_@EZ45V7 zY8u)g0OQNtGf54^mxvZ?Ng!d%7X$RJDPyX=Q##{>rn($e*Tcj1UpCU=Bw*Mo#~f4; z_zLU-(x@wp{D&l0d}5f(wI_3Ipc0OppT?%Rg|96)R<*7_snTxt zJmGu~su@^_w!jbGVg`Q-(vRWMmL2bQBW&~p9xJf5w7j*CY?teC{pFEykEKW^i+jg{ zTdLr2X-gel?8h7(6}mYXz8+eDqFebl5y?~>8e{xCv-1y|s2?vG>CJZxU|^-(N7ycT zKcBrhEv@bV4JJtA132gFQT59I0L)j_X#W5y!dv(QOOi72YHcpl$VAR6*!XvA%#qAw zjehWBgZ!(qO*t*ywlYM3a;kwvG5nrWa>=}7avT~SF2C~)VW|HADaFU|sjOMy)Um;ncvchfPr+T!fF|ssHj6DZhKDk@CeO8xamrsYf zF?9_z{EjyeKczi>8)=Cq=ezyNo>jTe<6RuKavO5XAIv!nMsrMp8|aI9kjP`sa#wbYh%Rm@XxCkXkwR;}ttv zUBu7ilnWu~TR5qeNy~ee8gP!*747D5vD?gu%gF$6e@e9kB?_^~areCiW=W>%QEf0i zzTP((7=S9uX|m66iLcT*J9$l!`qU`C#kRYaOt$wqj%FK|fHTL|q_Md2k+#TL58Yke zKRVBc!?yPF2}R&%2PC_ix*@g+^2`gbP=IqyIVW*@trou2*Gc55Xttb}1b$s=0@6wM za)n1O&A~rPq_aak-;?|GILReQQ}~Ky)y<+d$Q{g?(wWn(0UUOjv-~ z!2VoQqtj(Z+#O4LyMKo@nJlx2<542U8HrXM2=wBf{{UT|olN~2+M;vsnOYI;e;=s5$ki*G7#I zRvtIKBtWX94CQ8TxHw>|0mm#};GEgdFEmwQSI zjFJxr^QQf--XN+Sw-JHCB9`AS}bQ7*|;(NDx{jL3z*aF@Q`!&*BJMzlZ1X2 zD5<}Qx%Px}wOuo}lsKxyvtmTJRs-)YM*^zP70u+5Gy*Ny+@(-5kItyx`PSCyi`~xtu-FD6PKCQeTqAH*e%}K zJ7j~8Zfhq^(zV-NLPxo~w!5`{P`ePx><3E7hg#9~yTLqCD@_*#*@y@59cxZ2ru(wo zouqVS$NvCcpE`@PLQrzmGok(3jmOK~k;6ArQY7j*DS_O9T%@=0+Oc^Sd83b=$c3_f zhHD8teG>P`xudXX=omNr*l zqd3TJhPe2ybvKFpy&q?ozkX?e#!qlN)@}BaskMyO#bJ2K++_3H%m-JZmHRL52}&WWui-Uz#Q8P6_9`4s8A@f7JJn1CNFh)Was zRyDq$CboUaJ+X&@Bc0oq)Pc?^i+8BUV)v3=3z&l)iEjxk%kFzr%J;R3O&igqrrmtN z_bfZCxNp|2K_s@bHd8)@iO%11SUM)AE*qGx(11ybMZjKr9xHqMQWi{06oGo>SPHns z_0f{#t=zFLqZ9}m$#x`w1UWqZ6)e|DwRg70Bb6_-{uPxrvu`PAZK4YJ+^AcV?s3|= z`{sq_SG>GbkqE>w$Z{Jw2b}X)ceTl~-p5Tf+>w=v0I55JwYHZ0N$6@=2DY%qvNSRf zr_7O8mOZdK3g<0jxQMI6aW3fwQ_O!)K~ts9w#==UUEK@Gw0>Tcl#=Q;o9Jm=>Nl-% z98upyj#amYPn(ZHQvs>Wu&})wK_*62``&{Ui+5?LJkUDaz?TE>JE?3BW114vQIcr^ z)m}#1zyJkb%BP)oA1{%5b9sES+NYY12G6t=BlX2MOwec3!?d?=Jd*V-As~+3dVW<3 z$8`g|MJ{J8(U%Ij{Ay)XRogtt9G!4j^Y!MVnI&ddD|(mV(rv9-goW9@T>IiT2SAjMYJnncwNoc`PMC{NFvOy5-8=i zi~@Ugs`utKx`;t+UD@|BM0zb3_ zN5)1QJo{u+3lz}I(aS3N1Z74t--)E#uq2CSSe`VO&VMa>6>Z%8gn5OwJzLhD|qmn~zR!HO=FYfpsjTh8*&|6yp36cqz+(ygG zNc)dHx>RpxIf(Q6h?I403jSMjfhZ$4@>S$}YT$)Kl5&4p&k}7=L_UCWcG%U#Q`KVC~ zVD3;m{{UL8edbF)mo(%dJcJ}1dQ>Z=z$bHV&aU5mgAzu4J5gm~Zth+efpNK=PJUw` z#z)qmc_oopLeaD&{EUQxGwO5CRK}ACqZk=I$)|Oyu&nnbNZiGQX^e!DT24>XBBPq_MVv+Zh1|QCs5^(#)`0NY zPFb#2I9nhoPD%9!lkID`J+i&bOg?6e2FKJ@ovB8C%#qDM$e=09eglfTFZNst50`F;MhGAw1MsSlzL5x9 zh-8J!H_MZ|1HL^eE8k0vzT>W=m+eZCTQaE}%4EXh>7KPMt%!m_Brb*6;mWqaN7Fpg znWDONF92jG>=1J;l*~xbgm}Z$7v7M|iX}5QJkJ-y1m3Lz##I6APX1UwR?{9SvDEUnk zKRS7Td#6nCk)GJ?S~mKX^ks$7kIE~R`B=7n{VJU~B$+(v=ryIgnk+_TC=Pdk5yxJG z{P(N7*&SMFKnXFE&!oNZ

BVMGd3|AJ_LRJ{BtJ0|f+(h%e&|i6wKZpk+S1Hh$s?Wk0SQ$d zarLNwvY@qRxKSXBcSMo1{Og~zmsYxw?3fJp{VdEiK~x<=ZCVfSW(hy+Utv`_xp9KR00c zLX3VmsQif%BN-`iF>LR2=zg85gx42Q-e9~yo~0M36-q0iE>Ed=NgP)`Y5P~q2FQTG z2fk^B+AF)Ynn=~u95(K0uwA;Wkw~SNIWBp{R)*qeZVYLFt-(^mk8#Z=q_zvLr%q+K zM2RAVw3<~BN2JQo?P;C(z+Ku(=&X##L2YMP0Ps7Zek~q^K)A^)_F~i#fCqK zbjE8%m@1hvss7P45BItJYeK>_Sd@W< z^r&vd9G&ak+=f@RDY-~qKhOCU$~K8{bt?uc0a9>l*V@xENUW=ZK|_k9G^k4I&w_GhCl1bs76iAg^wC)$ng=}4e>q$~3v$nR14PI_Q|6=QH^=7TDLGQBAju2m6y-!c!a zO01!<7ohJ?^NxP+T2ji#1#o_p0~zKpCyf0m-cvB#RINy>v}I|nB%Kcw0zfwbh9eZ* z4crm=(_S!F@6;v+86eScv1gt-Q-EeT6FGhsHUsfWVJXhsnhOPAl?G@5${YB)QsmPZ`HPk~`WkAd z&BK}ilP7LM{bgySjT*Qr!LGYBn~? zn@G(fO$wYSqyw5myBqkXmS*loDs+#`ZXi8+)ZSj!Agej;#W6OKOiH8?xcz8}8zsXQ z^s9>txxkDl@3>Re#zr4}k6fp%!3) zijmw>Z7s@Idl>==HjkE+Te)qg8T74-T`N>{Z}dj%#zC!%9}8-842yM)ed1)}{{XL9 zO0*)b*`#SsPRSgIwcUVYJf14;o{uf&{{SvB!A5h6?-Rl{%<-)Ekw+lrLA#}H+IVId zEr_<9JS?O+RKsw3=hC?9W)Mr=-0Fr3ZTrWXU3g-679!Aw^Ez!b*gPqDEzZQUlLM(F z@m{kIfoB4Fw()tAFV1(9$Iw$G)dmC%V}-I6m!UrX)y*u;3;LUWXB2qFz>+8jLFzMGT`?w`>7*NjL&wMGX@#q&bh>X*o&GQlR|{bIH3q-pGFTUearUJ=o)rby?KV#MGuUMp#IJr>3y z(Z-T+Nhh3D`6GetUEbbZ%tcwXVHtG#?ot3xLz5aCI0~R)jdZ^xSsOP2=5}EDT4>zy?`E+xe|IY^ES0bl+$#{ zp9Q2cD(pWw8T|Uwb8V-@65h&L6mYm~Wc^JA5#CJ+T<6RCzSzxc!=ud{XpYS| zPD4FA1Ri-X8#?@MhR*}RrHtpY%pF~|;g9{g3gLPqPG zect5LwY3%Q%og!fO+1$KTgpP6r*wZW;A*YDzbo84Hri+`t@l+nf$5TcYo(IP)>6J) zj}Y#uia)V*wv}$>V)B8F#j*UWNTm7_?urYm-H@&JXwmu|qyj20?VH=7h{Rb|2WerP zR^Ojx4(*~MPu>|B#b+DaOL_AapBW$CTpZN9_ZqijHb&OxoD{l(IM3eS(yu0)szd~j ztH@V^Ld3YowOxl%E=v7~o-@MdAB{45%}QXR+Rh*c8(b01K5aJ(YDAiS+=FSnkf|K) z7(Y*~BKT@yF7%Q}&N`PQ)vFtgV1Tz4QA9!NWX@|ywcC-uU z-^LgBjEXJiwUygo^W*t*S1vq7bEeOmt0^Ty2hR+7=CRG)%0`y@U>8lmdF9=?PjWhn z($eJBqiIgC*7L4EbWoHd>O1zUany*mSGw^{>d3O&X%{lY!wa~G@y-ug)LX=uLN4tL zcRP0{9%xhQ8>VUI;(gz`v5HW61)ThxcB-<;tO8yrtz%u_fW?@f!yHm=ZJ}v0g!1^B z)^`adoHnX5lSo4C9)wk^gR9AA9_HrFp**zFsXr+ly|GpoNjHq`s0diH@)TfW>6*6& zk!^1QT*%3dp>x0($4VUH)_|h=obH)t1T#FAnvj+kIU*wK!8qxjJAPGW?@EhQfvw}Y zm@1rZbLIo>gZ(`#Ni61xysJ1>6oLQ%3{&l`FCZnFBm^F(n$OzFyY?^H#VZ_?UK4`e z@-Vl{lx@a15TfVYlUoU->C5H`RD&QYe|p#%6|-|;Ykh0;P6G~brkiV~s|84WwhDKA z+|{Mpcd?(BdG0HZ16mv^v$7Eo~ZGUenhSDrxgq*Xam_Ly3PrR{;@^yEa)Tbw8fM6cg zt7~UA$5xT$%NE@r9D7o>pC!;kGe&vIP`~3tS9b-Xv7c{dnp(43F_JUS&ijp0xzsNR zYq*81aIRO(W!;0*r&G_Rbg|e*>;f!k!_a1{GDRGsFEH?Xu0=M~bz(~TA}ckOBhB^U zb#e0rOkmWna|}gJeq7)*o$As>Zossxt+eMSwHFcE$r{LGNeY~dnue~5PRzi)*Ivf) z7UJJF@|~+9;I3<88RJw5_KraQ;QqA~$TE)5sEnMb3z8~S7Oy5kBDonPuQb%GwA?Ly z$-KA*WtF!!InRH>t39OhDzaT9QR5&O@@mA$QB~GP-cLbQ3^RZvYohDj2%)#sX?7A7 zCP}k4;s+a3uhyhc@dfi!dNJoKoK&Jn$_#m9CxTCUQu0d<5@_B14@z9YVpq0-qRNq% z>FhnKC$@o+nrn1?cVG`bwB)mA+q!Uv(GExJRWC)%cO{_)MI3A#WKky4y@ai>3FeaF z78`h8+<$u@ui^RBvZt7Kn8FP30(BJ?yE9>AifCMQ&Tw;07cXr&63p&}@Vsz1rOvH! z+fwrkLKDdZpFz~r5l!|*c4(YnXNBumBDwREDcpCafgna9!*QN_Q@>OmOsKLo)(Ke` zJwP}=tv2q`7yaGXSA~deugNB#aLnqyWMF@^t&CIcp^ZY4UQl`$H40Z_Ye7Y{9$JXw zF#(QZJ%?&+$RTa4WNeR>y*+4T3Vg-$lRcE@6dT94ZPFx?WZm5 z;AG*Lsr>2dXDpDhkz#o<{7gq5TC~&spe_K&KsUc)0FI!X)FxzN2m}RVou~QJx)!WY zutp+s>aD+$H&Yc7lJ1=B8Po=&pAjKqjJT=74SmNIc<=4Nc<5sM%l=GK`p` zM(Y{mk9t1F-)Y|zz(?05K_~I5tE@*PlCJ*%D5Hd67jZu09jedSw-V`a?sJ`lVy(wP zT$DnH+1zqZ7#vfWNg9GCCnKmG>LvSIFh<7Q;PHw{10#l8kCc7j!#SuZg{=J6ZL>;* z_XoeyoR&(k`7_G%=Zv=*_Bg3_F_5^DP_54#3{wmeNq6#G{H@0$rAocPWvmcbA%Y{d zbDS3~pU$VawrjYTF%PeW;H$jd-9`v@h;j%IUuOp6n)OT~Nac4f{_S~*%* z2Gh_k?o4wmM%vP z-l=S)R=Cux>=b>u-XoqIj_2N`ifcRAkCx8yuN#Qz-!%-Du-)6VcTAHjbF>VDRqkx$ z8@!8_jxpODll~MYniIXvA!{750PFx>RgNi=SwOBGXK-=BQ_`wgTE_$?7m&#rISkHC zA7#6SMiHgD#v9}%i)ZkuyXZesz?w8?KWLeiPtI95AB9$m7Pz}I!FsI@KI}im_4NEI zReQLVf%R0F;>8P0lj zt5KVX;>eYs)!&c96`wYtZ*MBYC8X|KEOw3%{{W8^>uprst0k&9*~2X0rai?uMeop2 zlGwhlE*s9YjTmySq!a!$`AxLN5@y7N;BQ>iFdrfrWVtZx9aJ3S@v6|@>2uxfj%b5z z;4FlZ@AaW3!seDCNkBix#;VPI z9-PKmZixpifIC#SnuJ=M3eZUVbHO8%^`zw9;F4Mox3-QpkjoV9Aw07-N9CGUcxPRK zwg7RrI5j23z_EzQBQXdtPC2Y=pB8B?2kx!`k$58==uwpRK-!Mxr`e*4Q2t|uMF;t$L9UsN8wc;!`g7VTZ_M* zM&zBi6e&G!#M05ru(*0$D>2u+o_fQ)WcJXWF8H1i*qX1iD% zhC)HjI^#!SYZ{B$BRJ=yXY;D(mwgH4U5w?^u_SWBuoWwi%rHeqdmg1}Y-Nl^BdFmN z@_j2}8+8B=HKdV72JV!N9m2>8TSWZ*;CZO#=67Xs+hdBik5QL0>KalxZn%&Gk7HXF z(Jke`W{ldbNB3yi&TDzGJg6p(1FslvF`9M7smAEgoxgM=rNA#PXcny+`FGcw#SoU;Wx&zKJX0B>sOp@vjeZSM=Q=;RV9(ps4?4A0m24_cVb z#ppK_)~7Dhg-I=KRx>u-va%38fHhphuS;;TeU{odh{L#W#C<(0u!`E=7jhzFo=I+T z^r*#(&JOLwZpiKYs`=uXJgmcO6Ju=bnsbsyS&@NuHP72xrmL-;!f0bGH=$lvjs|P3 zn@iPR=VVvWq$7d~oZ_rSrW;efB@D!T*x(;}Db{dJ^DtY&)_PSXy@^vzAQJ&Nxvz8R!v5PnZ9-^lfu93WA${Fp?+*eQPYTLx7 z(PM$+B^MvOT$A;x%9`0z5sES~!VSuJP(+W*Rgy#U9@Sh2IpRx@A>}#O4agUw<{o6)l_7FIn8BGe#&x` zdYVcc(MgTbZDG^&_~Vx=Cc%-9Pv=*X*S?vTm-G@gk&z05Epqpi9}LbCnU} z=G=S!AB87<$7E^E1IsRa##Kh&>}o6Hw;&f87$A43n^v_!<)f11WYtOKx-u>mLY}!j zJO2PGRvpE0=ECa;G3{>ZcdrIW;LC7^z>^^LT=5`1>4l!13t)5~-F-&7UMNKuBmKKan zxB?E)d8t|h)QrOdBD`OC3}p4FvXU%K$J=IuBpgt4$nxQds2}Z|@qO zVc5_S!>~r@Dn<&Ld?F@)B&o^!yl_CQCb=zDN6r2V$DIv6PMXD^J zNMfvdj-VQ&s$NO3c*nIrV9p500-CnB3Z#>tr9&d!ZrZ5bJ5v#0kO(6K@Ti(@a9C!dir($m z{_TziXw- zcg0(aO1f|fQb(y6t$TkDO(;fE4zchCgDTwMI>h) z)LZxrNfeU4HZOc)vv`Vq%T#9i91yr-!18EoqmBn(O7%N`hqiu3Ww?z)4y2AMaq#0$ zb{h@h9vE%#R(@m}6M6{9hBXbB{YC~N`iij}-G zq*{TUHYQB-xbxPtd4xJ9Xs~mAPYv00%-caCpZ0lPJ-$mEoEA~iy|Od$&~{Ocih~K zql)%qw}d8QiZPx(@AIk2nkYdqsQ~l2%2+x}p~BmIKY~)q(xZ{i zLv-S=ufxTGvmBovIg(Mi?$Fwx<{`$owin3|8ZFTt-}; z0{T`mlY6sh#VwFL2?Pw$K^tu!D(0uRh8w8XYm0cd4gsw1w%eg)^A;uDlbj5ixodf7 zcWjgu>wqd0mCLgkf1zozymO5{CU9^YC!eiJ0?Q1sqC*nG4hpMnAXSFHw~8;BvIlO} zPF;6QS=Dp90|Wt@yK@t~cnX_Ibf)dcJ!}01Wcu13zmK`?{*Xc-_yiA~Z z3%QPRN2NGxFeHUqHaHw@T#A&V+^fiiVvQs%y9%d{I5h7z-bVBM_hnIyp?Xrbw5=W% z*LMd41XXm^-PQj9&_bdd5^>h5(F?NkEKp2+}h$>c^PN>j0Ji8zAYB$%zVivOnj@r2DkLx zM(b6y`$o{Pob6>l=e}!MMp2FAh>W8rqc5hFFPt}DxhwoZxct7AuM9TpZ?ahnemKo@ z{{UvYgeGM3MmfOdp5kb&%PPpMcmR%{T8O?<+PSE7eJy2a7ABOj>%OK#XJT1lwq+!f zj=a`ZmM@HDcn~ret4j0Dz4ycwc)$nx zR8MH1W*%Iv7+#dfB%gUha9J0TkOdym?8A|CBENgM*LqyYIKc|Ptuhm-O47T}JV%_W4F>>fX}6)HND!RCcI1Bx3Qx|3Xsc?vJf#DzxT$o~NA)2Fc2 zt|Q7{fc-LK3!logW}I8Pq^JuHxIEL1+sttis%{tuHBGw$NXI%;$ttDHo@)gJ;fMhH zWc_KEeh|{HP@AP~-4LsgSMjZc4`}TqvIaQky+rqGIIy)y~y=uHL2L`GcR#jeyEy$>5xq;?l zvxVU8CHk68J7_f0dY3%ANL5sYh@6~(jMbD_r3w@ysQx32S0ZnRVZ}Z+x|K+i%SgfF0~xGH z{86I9!6KX<#P%fCnAL4(ZHaRZROcJ9MSIjv=|MyFwA!zTh-LxEM+KbIR zT*hQcwlM3SpXZvP9+x1!GEMerNf-~eYcD)is!cL^%~ZC_E5~%jc-)z%-rOa$3%)iu z>4BVooKyj2wuMA3AD5hN$4`25-^FVgH@7kT*v5FFG_(hDoyM~y7QS*@xIUy{^I7qD zzfKGm{y#6Bp@`rSkMXJQ<+s#tASUi3P?qh++ ze{)gWUA4Wr62_k{M@r>m@ido{$6;%3R#JB{lwh}hKhJ8{y1cu$&AOOo;HzU8-TwgU zsFWn0rKv@&4HB_lh|9;YbsTi7NvGReA#H&{>VK_fE!;6HH1{ed0A+K)tj6&i*D+i~ zk+#&x&OY}&zY4}S=Cz8GvfSua+BDhra>W$$xrxuMKVW$_mNBpy$*(`tyh*Q5Jc7~( zXcb97>H1WjBJnn@4w}AwtdO*-Fv___z=c3q^DM!3TDZS^z8BvTs% z;BaxpdB29`)%7^S+{o7OgM$4DKA%eLVzr*pk}FnAg(H?}4s%Ly`IXRLHOy)t zwSoHW+`Z|^DTMu+b(BfB?*Yf@R$h7S0Wvcxf!D4pK3!5Y4KBxgb-*=)O4=IT+_N35 zo0oK(hf}$^BCIXiM4&h*0l)-TJO2O)hLZ$VJ9*6R)Nv~SPeDJhxu14(b;;U`MPc_^cabt2> z20;gDVrr$vu@$9PUw0@V(L|((24zKTtAThnmLh?+1dvPs^=eU1B>}Ra_;q?)#)}$FZn| ztg<^ice5`>$-&39Q?!EC4M#Ud=H_V*;l@`!xb0J?p<0@k4|8)0OJ^c-*(9k4(~4}S zGXo;Idx3z=gc82hV&Zrr3hxLIjAuO4;fe_(X10%Mak!NjCZ^>Tgou&+$uz8^oQ#oK zSB7heqicK1h*gf#8WWGsr@XhkOKFx1r!toNtT+piOAeHhT&=~$%&Q|N&n*cnkD=&k zsK<6oZ)9787CK=2RK`~wWZFh*jGD4X9{ZV4z{8F11w(7$*e&KPZ)dsOuZR){?2X|V}w!FTY?%`**bqM89=dZm@{{RU-m2B-Ru|^{YjDhs3vUtBv zf11S&#F!+YQ%%#KD`^SNH{8{V{oD7FK<&8gPzO2msXY7HX4auGH zBxnV!icS@q4f#~dX{z0@jLaemrHiX@f6i(l2_xx*&(^IiG;GfL>QIXJPlj;`vz%i;Hi zB6y4{IAA&bD)sabTG_mkym%uAE7W>cJ+$^|9@Mr71MS>61l2g`E^SM5Ez9aB$s3W5 zL9e!!x3CC~2n1J7?t=ojWsycI~nDtR>4F+q~f&H%vNI#y}B=u=4N z#-kn56BWdf+bAG}ivSM%;;OcrWq9i)o~tyw8_a0;0x}3V>6+-4Gden$BQdiKFQ}xs z(_^=_+Z0U*9Bq%OtzjgdhH{H*Qx{LsC%e2Cw-Y>I{K}cf=lWFo%!y#Iz3Q-0z-an& z(xs10pU+Vh)y8wxqsaVgM&>A`jZ$TKlnj()$j_}3ZM}8~t1S*vJNfS>c&&9-j9@Yi zp@}&h5Nl$_-(B*X%)Wwhe(L#H#aXn|Qd9o`9`QpabC{O^{xy|*rTB(B{MyVCA;{$R z?M+%*M`Cqavunzl5RWa#l*Ka9fq)NcsedithjiPSRAo{=tTXFO(m%Ft5=GR!vZ`P5s2^E(G{Lj2vbfBN-WeNN^J zh~c$@DWWF~!M^QaTiq|)j4aN4paH?;pIY9tv(a8wXyE?_va9 z+{R-@SpIX-PETxBmYsO72zGP4b;#*XmeS8^&E*}*fB^ieu;BcR!y}W5&9%_9pHf?^ zo!>rl864v{0+tzKDf_8d1;;~81|^RHfd?5C6!$3vBXSLdbjaeR>#+7LrOTv;=G=MD zZ^ovM248HR$Q+j^v~9&(m`~~$sO8C%&b{U ze59U(=|setmNwkXP6-3OT2~5#=2A2AoOSl7hOch~yBaZ&a5mMcUD#U{*m)|!Wng{U zu&-{UBo$+n@4KiZfAzg zh;Vu`j)&Y;=&om63y-`<3)qU%ODr6y-L-I|JXKljr((=^Zf=7;4L)UH;q0B6qK(Bq!j72Qr2Ia_9a zxic-uSd{USaonD2&Y2X85S`0%eozKReQDyt>r<9BT(qj=0eHyGdXAT8ZDpoJrWn>h zyNJ)OGhJ0N5vK(nq{54wn>n2;M7+OOl4xYxj0lM5>T9gf{5mY6X;TRy;F5Y)tQYY| z6Juf$bAWo)dyPf6tWZV{{{XzqdJ5!qT#eNC_kvI%b&7MFW-jz=KdLpH;1m|gTd(s&0 zqMWp09av<8-|1GRmPpVKEjJ!W?nkJ_Rmm&pRzxV8aHk~WcYeqDR@BQ9<7mmjO5IGHnDDoMIHo=vCbP`vf(D@h7Vw`5DTha{er zQ|(a%G6K7ox$9N`0JbER_Qh<@nZW~$QDT^%UiWwxp`3O8U`xS3ECFk;V;Jd-#MQ z;gm7JUAXDon&TSqMC^sfUNhdNv%Gkv4YYK^jAxpERkFCfv)Juzbx7hyVgi;JZO5Ri zLgtSZCZi)U!TJjHc)l04!Ui)1=Os^J+x+|0O;6#YTiYy< z%!CiTbHMhmck5J}wa+bKswJ_($9*sNk3H(j%PfQiAZD~6@V(5Fh|m(PoG=yBX`Ty= z!<(5A55HO`iKk6!!WenY=!_jZO}V_0Kwt^vd)BLXY2Ef9C4!Uko`(e2RJNLBg_HSG z#$_$?;Ee6>`0-U`)#8BVCHtTZZq819J6E4PeMc{MW41U*C8^GT!ZUK#k2AAvizIQu z_qBb0rNYTBw_z{rI}L!G^Ij{gA9{NlL#yV>Dju_!8fU}l{0Rb;Fv z;i<*knlBGQGcX|n^en!Z{$$hT_-ici35(`4f%5Qi$4vGA0P9yQb*(}t;5w;2fv&?z z@jj(CpBw-)F+DwKb!*dClOM99H=;S&JSS~$b|4a{D%d6Z3hI16;ms&rE9G0uY_ZSE zNFAw~zJ+@&zuKA3dj$mIu(bU*R+OEyIs_*tkPrFdrPq~6-TB+aCt$NpI)Q zS@$R1QUTA`@T~Rlj7vL_IwWL)hdIa7)|qXl--2H5-p0kQL6R+cj`W3-*m7 zFg)o)gkg>S5BdI;ZErLyaD16Uo(2IwHhS}1+gVv-%6$1jvIcsbbPHM7f);8>_BW4HqSb{;%YSNC*&t~SfMcjVpr@bdQrJyLb$#1orC<2j??s(gu z%cVLm5Lvt~WQ>(g0nT$#+(!?T!U$CvxC~b~tZRE6Ue@)l+2Oc|@FPFsMI|eZs~X3} zS`r8IL$2NlDsT^{r9*kEeWux^(`{6-0IvR@=M^-VwYJaLB2vdMfCv?rajbzTRtgmd z+yD&yY07HaAW_#=U(>ZMTJvCd*54W6n!9~}B5AIE&`Sb(3g#m5EvynEsbeNi{(5s$ zU+OaIi4=Cq$sfP*9_FShP2Sc+ylr7EwS7})UpbVF4qJooTQOc-Oh=t?Rk8>bR?9?x zv-yo61oNB{aB4M4REI|duLSn#{zu_cHrvpsqe5ho;@)EN4dCQ3INRIvHG;8SOc%}6 zWN5>D@vD8|_*V8IHoF6ZmG#aEsuJ0VPUzI;M!`A8dvRA8G=(HVZ=}N;i30`%k_cQe zALP{6wy6{W(a9%)hNzlQ?24`P1;z(KR^YzhwHN?n8PC_DsBOK*td3h*)YU>p0cjNE zfIHRi4qaS5*2XCq+w-%YN3gA{T_)CRmzGG!m_~RU#a5$Qb3iHE7_uJh;ag;yaiT-!jF2W#W!n%leWgK*0BWlE3z2!TL5k3n%6~#?B6OXxa0r^53N$R(5>TG zqzCRO!6T{bOM3qRWqrVn!>9uT-lC+V&~Q(wqZ6c$v=Qb2PfoRUV==~Z2bqixYtF8< z+2Ok~#Czln+{}K`H?h^N^l{2#46+tKd$ww6 zF0Gc)mNwjZ-l|4_8s_Y+rMP8m;c>Z?sm^oL>sq$<3ey5eMg(Ud{qDbxt0djHmu1x4q-M9J; z^5#bv0GS+qtkpv z;vGd;MPSDqf=3tw`PH2>SijaKTOYElVSm=Ut^gnYy6NDCTUAKnnljDYF93T~yFppU zQLD>T^f^mCUspF6p4pHOn1%#rirUrn3)^iyXNgNYC;>;fu7NBg+I-1T%OAXY;;R1u zrb^!_j0SDLFz7j`sSangij1tcIU9XTTewjR*)|+>ZV4W~)t7bQo6SPxPNqvnRXzD8 zyR=reETsWKkRLroO1g!-=14Y%agd}AKRT#M)A$vMloY-vbBNRYF=o+))Fx>pQ<7JV z*I%c{4xgt%XK2lY7+>aponqd@sX-y~;@*Rij)Uv%RA0qft+Th8r-f8JzRstCLiUwb zztt_)h(a51udXj6OvDY;#i4@IfutkrVnBy47_||r{s@%gk z7RT)bu6D$8&%Gy3TOyR>yE^#Qt^WYkTqq!9gUA`D7P)w^&aC_rM_S|b$u$`VpLop? zY-Tb2YpS-??4pPFgeXyyk<+z8jkIOAeNdMV=3B5XNGFUOky(RLB4UCE+(rRC2iC1! z%M!XZluaa(^i}A_sz#U3=Sg*H6_6E;LGRM3M?qgxPfoeLa2`Yn-;>)lEx?q^l~pCV zCAw8RV;nG|F=deB=3|pm-$@y?k$%zp(l~66Jt`a4$fUFh9_}k~9DvU<%bVv?9&wGWS%43oPY9 z2aGp8JJod6^nHjGxL$LU?N%=|y&^?toE`Y*=EgWR%W7U5XY!KP@GO%^&451YpQqRK zr5LGb5|fU{SthNgIA;>(HpmU0DIl8KH;t8x{M;Pm*BzyJPVx(r71ieGLtqte>0KlE zep4KaYjh9yKx`b;%_zwzvB9>k(XTTLi3ayZ3RDv3^ZjZ&yIX6>l?1T`jE2rW@1U+* zQPA~x@V4_8ljS2Uah#n007`fEUGoHq?smHj<;m++Wc9eYp4KU9wz8$`eU^D=cHNL0 zrx^ZxRoyxrL86K=X(VeB{LaqfCmzDC+G$sa6zqwa2g$W~Z>jxjLKwBxE{z-_1>~Ia zat3i)y0%tEYMtH7dVRb90I#@|F42vOc&eKIv2&-}iC~#eJ1|CaYC~xxpzm$1E;1C5 z2R(hMBk;H`CcBmAVS<@%GtgHuPExx!dMhKEgT#9E)bYZxV=6MtIL&M;2op0{2bNMm z-ScCUo@-(|Ye-}ACq(79kC)P|uA6HlAS)e<_fC3Mxi7MWqSoxikHcDR$VQUV6)H<@ zQ_`=tjia*s@Th$75aZgLapCD?49Rl%MmP#_n&tHy9d6b~nM0LDI5{UA9)6WEoaMU) zqaBgb%LSg7iP3__gR8bc$NBv!MyirV(xl5LJPdFo`UCiGev{w46`#;VcXY4>RnB$vw^1KSw4iqErvUR8c~4D-!RbK#h7p}3mTONj0W0aQqE4tXQnrxe)qNn^PYT+MkP3zc1& zP;=b=G?PjxUvD7ge9hRJ%HvkFwh1hYbuzgj6oSk%ir8&JQs2I`^4-vGB#!*!@T^M@ z4gUaT-%E83+`CGa@{57V$K(ZBmtV1nc@kRP%_bF5>G@Vo%vzqfrEQ{XHOK?zIl!hxqWGIl z#E*W98xRTxCjqFCv&q>;|~ z{vV%$c_)urPqW7y?JB_@*2pq<_pKzch@!^mMmgP|&a2GvBNYIhzS$p@XE)Tiqdj9D zVmwkw<|x`Tou}}rJo}c0Qt%DiaIDxlC#fIH@UCyg*ZP!pL|WUpP|Cr8!4$q4xzz@o zWxk3@%MrCt_i@&QrOV9NoR>E!w*or}jrH75EYJ5NRv_SG1D-R<>F-zV?gpc5yR^w; zM){do^*9{#=ZsdBt(m<*-~~C#lD?g>S6toM%CW3!(Wx6q_p6lj6k}#&PX&dbEj)RW zMFV3mVeLR8 zvBf%r8?5X$g$E!3P1))ta=iPb(_L-UM$MhOmpC~80PFOu-8RxmZmB|Hw`@V$! z71+X{+b%YY9P&RpujLUg=6osp!A5D>DBHNNc2T?#HNTfE;bdH3?&md@bo+ZZC5#YvXMh2! zL#GpD-jJn*x{1RxKjD zOnR!1UbUQ}R9Tq%gN13Wl#!pgw>hYjT-2tFEzXM~A>c?Da7|BhtG%Z`WmiG`N;+}P zOQ&l;+9wMEjYkJ?>+ky0ib-5jZMzUbZD{d)_G}gZ0F79ToZ!{D(iu;g`@EBZ^5cwp z{uOrvVRz0GkW}=jjoqB9_mpiI0Ml|oV;cH9m?A5uD2Cu10_-;aKGfYUb$*xeKqYrO zq*K?@w4i-DX&w0t2qckG%Pd&k23?b|>r>2`q*6d?fYqo9gxwiwr`h9U(dkHmuYY*Ei+Q)jg5;AV`$S1Wq zU8GQDjF|d?jzx2Nlp3U#ZqQzAa5k=2uWC&f`)=A2w|C1VySWU#J%{H?6l9g#DpeKi zk=8oL<{2=_xZrx`she#)${JYW^9bRH!Nzm^>f8=kr<_-El6W-ft}O-L=9LQU#xM)x^yc+oH$NKdybMH`MHribb(mnC-yp zLDwLT+)Fd;=jGfz`KIY~4`>l-Hg_9B*~H;N8D!~F+v#>TZdq;Mj$#THQH=9dthM6m z#fHSl?UHlSs_MQbx3MuHiLNJ@<%dn3KtH8EN3s_(+|`+F;zfB>7cGFwGI87a)rOuJ z2QmzFAw^Vz?|r;;JaQ>@&z3;S)b{tVJ8dzM>JMtoQ(emEWJ_@bjWlsvVV9P|^%Y#n zad7IkZy-c(-f_Slf~C8=X!rRDHiMSi)c*jS3T3A3?b^e4EKgkLG@KAAF}H5gg+yg( z5PZp=dR2ez4OLZ^D-@0~(1+Ye1JnHWt+?!BQf3hy`N!c=+F6L-DY;WQ3OmzO`-#u7 zN(;?KNtHgxQA+&IPeY9Kt0`|i)(CQ#1QU)==UT&LZq0&nI#qdZ;7Qgmm@ya%25Qt1 zJj~3R%JLUQNjJpD<}NuDx3-d-Tn8#LFhgL|u?^T|6jla@!|rtGO5hzFso*P1x;vl^pgkfd?-t7sM=7aak`EV8_juaW^C zw4(^6VL3aP$)?Q8t0>BoxwdisfBN;JmJw{h1b{F`YA8k9@v(qCNazgV8x#CG*6@WXEm@SMHL=rL_{P>bQaE7_OAY0T z7|)=sMe%ius}hc`ow4`1#c;OTCZh6~o)(HwGq{idHM41>-@?JBktXDVB*`52#S*7V z8!%Fww>MTnVlvjai0BMdJsr zU-QLY9vHW`jI?D~gILN`k)n-8M;5NPsk}k8-GdTTf-(Lzr)dql+m-SoQJu$*cMgWR z`_0yJl~~)ZN{W&#UTbwb;%%gGaCoj-vUa*Pjh5!)X*S|g;t&|IJH2Xn{EKBWoNno# zUTTaQv)nSM;A|a#okcWqyoJNz4`I@?S9_PILsm)Ej#0wo{od73%z?_gD(>NT56k(A z&Mz;RGMk2RkyET<P9seZ+29kQw-=Wb39ImKxiLMv;tIVm@}kuBEf5no_bTwp&>{=GqG zs35on6`6;pCluzfmgamS6hYLHj`g8srVBes8a=Hh(UN=fQ*~`fv$(%$MpNfJq56PE zGxVzOa|r?CVptr9sP3(&W%Rp{ zs)yyk$*k?pfb3Zt2aIw+{Y*pJh>5Nq=SLe*HgkiTJ ze6?~pzR_>CO~^KbmG`H^WX&vx?!cJ9#!FVQYpI)8*u)w=td~mB&aOjnQGmhk#dF%4 z!3FHYEF<5Hde+{u#uktwZs)JvKU~)#b1ls8{jyC{Ke-L`tC1i!>5wo`A_fKqet;Lz3ju`m> z;d=5j?^(`CJqHzXcp;gjJEV|+I6J!ieQI`DA#^uCyxxQ^(~p*xITe^A7GkOnLH>0@ z{Wmko9HebK0WIl7XLdHUEk$KGbzvJD`Qa@Qt^Uw z$YgGxm2;EJFmmn=2*5tor6qGYyBU+pH?w3b1KXjj>6ya`6}EzS=QVcf2%MQPNj%^l zwVf}U<>AKPn>amd(5Dn~NPAq!c8r6M)}>pcwEVa{o@+OL(8C<(y+?6zEN%mEJ!@A< zOF}uUOt)<{*HB11vTI5^=3kWncO6-e0J1eh#-C#Sr2C%VZ?0LHo;0`~TM>W{Esj9N zXX{$MwZa${<6`HL8ObN#{PnLQ8pXm&85yv8WY(6QsXWd%IqQx&Cb5%%13UfDQBHDeTS?bE zRcM&FvYl2kK2-;C{<4Kn?=83{7O}u|+Mso=gOTob4DsndD&9PHoELj1`U=*3Qgo0aisw!(mAq zus)udt=&%L;J5oSMZOd{SwfMKo|x(BSyvHGn*ekn2GN!Jo_*_j!XteYU>3?nha_;v z6r}pH;<^>|JIO7|y~g5R9tp=IrCimoEp-`|cHO)Kxp9>rPI&(S>rzc@kOwX2XADv2lhhkki_RH;FQ$nR%D8uXibNEzR__VNJIw<31 zM*beT`c^nMM&!q9w8Ffp3Qs}T{PwP@(tAtmRF2{h(xTyx-Z?$}&-m3iTUJjs^fBTZ zW}&C-TP9gZ+75BYx2;pXvug+xTV%b3iHVHsxK+ zP(~Agqp;`y0IynlJ^WJ0=mbj|ovOI|#~rK6JVSAFYjDU591;yx(zV;mJCu_S_~k(v zLI%D@UXFs^x9RoeZ4$oMZY|Cl`v=+V{-3K7SbniNGfu)RWJDt?h<5 zi%7fxa5?(^bxe2@S-zFL#YMrv#t0vkZ9;@2{8nXBq}%riFMME^7g3e@RYx56s@I+> zm97KBBLq-B@A>s6mgC{>q349QR$-hC!;*Xcxvd+2hL`efNeZbXZY8h)?_E~IEpB6a z%(bF;nYBY2-cF^LfTZ*K*P+?P6mf=w3mXoj10DISO&{T&mt_())afLrsZ;W==UZ16 znst=P8M$>uIb>Xq$LU;E)EoCUI_Wtj?-cK+iU=fsIPfwv*N)YPZ>rBd)Mhxb1F!_+ zlm7tM=B#V6S;ulDMv_!J6ip!7W5smNMrDHX|*W41uUaLzhois`JKE#;TUi-?dZIrj&O&eUY{Wk*5| zPEH3o9dau|()K;+2$VPna0i@`kU!70IaO~!j1o2OwFqLcExYC?1p4;=m53*eUj>-6 zuORjnUh@58xpb6_5FDd*Qa+vk0LHNHb&c{ooMX_QO&qSkr0*BHsZH{0@@f%V7rs4e_waceUyQWjJLKKzgK_|Z;{N$QZL zS_^a3?=*{6v`G9jay19{7K8C4YYgS}| z6UHQC^PadL(zB%T56-I@WI%YwRv`ZXD$Pb$(H7iR<*V%w=z(T}M|ny4m>i7#KhOA4 zwzzwj8&xBdsVwzh%M90iCLyp3QDeWdv@ZjyDfJmTKXII zW6i{5?fG~B^XW{RM>0g@?jy5$`u??>4f9*N8Ax1`2JSll0Fzx5ul8LjFvYr~DLjsV zkMrwTa+_S_?zAf>bzrK+dgS!~01DW&5L#QT36@YZw2#O6(?*=vQAsWvfBLbs{qBFI zOQ}SnP0{X9h$2!wae``-Z3@XdlQj16&X0fqH9^Y07lJ_QGyQ8qJG*(80d@w*IL<4T z2(c@)nK(O?9x^eH^Yx}fdpNyShawPmki9z6QLs5&>*TgGLhO?5X&W2ITIRK%4%yzz zB=XL|6+j52b`_;-a_NsanE-AScRz={W_XR!o5~xbU@`KZo})gsblu*B&uvdSz0ma= zd*xj^>6;lpEATU2MwJcafFEnQT=!$t`&PZ4nP!%FjU+NiON_Tc&~^I$wWs9RLh3G6 zGK6j)-Y5S6*NW+>UAWlF6m0HIYaCu#`z(>HlAO8w-9P*4kQ9`oCBsn<%^0gkN zbeA{3Wwv#?`oSvBV#Y&bJv0N{f%+iDGQXSmtCMMxkX`Kh$5Rn^St z^|N9YDeav3ybYr`z$Bc02BV93htGv@j&iveHEQcownB?>Zn)i!aaKRHqFB7u+KCy? zI2Z%}0M$y(M14iKxmA&3l0&)47{+>br`}Fs+G2!Fk}#WdiglmajAHBWvwZ4u4_`{1 zUQ3PX0;FIbSo+b*JCrYUNiXI`kyR9q+>O){!0LrJ6QS)ds?Pb)*Z*I}W3ERT-!2baC zRvfTva_VupEVf{iA<4-903y0uy-wQ6BUv`aU!9o;cNK@NYIk=w>kgSZFU_`2I(Id3 zvUVl6YnhjqS1{a%Qe8>;6+tXMwQ$KYT1h35s=1qEWVl zHt(rNQSnBXb8R=-;W9C8qX7KJt}|ISw%Xh`9%4l7lXP5+udns4+fMMtmu(8-5O$K^ zG4GRFaKi{BqXsH?=luKCD@SA}c|A@NJttAUwLiRgTYeaxNE~rfX`UUsvec4KwY;jw z=Fjls+Pe7d#iEAEZl|97)R5kUFNoJU&q2@9ux%-8)X^)elnwjD(s@vqRVO~9n!wdH z#mhUw@xI@a1DtoR)&_(x5vpgX$4aL)y@M-xh>WC+=CX`bb#CU3x1u?lPY}%lZ1RA9 zepDRi+v~+xPY_1&v{Er?2OB^q9A}gIVy<0TS(ONmsWBU4VBDbfs4Vm-8sr&5&+}xt zY;+xZR8 zSPg>*0Q=&klETW>0_;~jo=1OLESJ2{uHK29y_TW&v|F2tc0zar_3Qrt>ZV=zm24EI z*K7`$EOTjw?4FW@&bjg>U1L966a9G=31bOpdhq z{B5RP!foVrk(go79-oanU-0}_w(A|cA~y;1bPLXL@6BP`d@^L7Ioj=1<0W&+_x7!6 zMwPW@Q*{&3Tco0;$e_u|+_1BA4uR&t$}q3E;lCQ59THgMP_pC!^C|CF7*w^bp)RB^dzmrm-ayQDhp5&dUj!4H9wJn3}J4ngrK9pPO#7Fb7_a3z|!?f&>-E`INa?`XB z&9MQGoQ5C8{{YvihNzJ<85}Ph9PwQvX*R8$$`8F~YT6aG&=Ddi!0Hc5&Ee`r^ENeF zFGOXXZZ(T}e4zgT>tea-{8w!y!z3;@v*AEF&1!g;!uL0DO%1DsMg*=q^dNsf&a$)* zhSxAETwF^TIQf$tgX$0BPv9x44erG%tvxm^*v~clW#maC7z7OW?Oj6K#(c6H#fX?24iqN*P5FsBkh8g*fN~qDD?8fTG$2T3+x^AWAN()=c{{Sn0 zckA@62AwXZ-mitg+w`p)y*(~pB~%s02_B#Rx_lN8M(iJH2a&~Bv6jU9Rk=w{!Gpr8 zj!jz@>nm?7oB_xcd7_Cx0aqO{Rjy=sVP}DN5I*Ru_FSt{J*PIq2{>($@${+_S}PWB zFEU{B-la``C6~#b7DohzIO8>X3%D);Whz1MM^pw_)YRS~eWy@;d(j zg)N+#gedY{5L-A^>;8DItNj{8IortWYZ~)MwU+KHgqm2{3BV1(`j1M>>g_wGXschK zLA;jpj@+(s`P1HOi9Sf<9Q7x)I(ekGvNCM*CRECfgCG8?lFwJRlG-xLyO?Bq`_USD z+TiD<>`}SXe%0m2JXyfx`&MP=f^Dwu#lt|LAi}12&#%_HbE(_1sXKB&9GY_6$0s4M zIV6+TwN%pCkmla#<+RTS3p=)%gE?RWGoHVNbi&3ZjDVpVJ#omWn&<>0c~$AS`&T=6 zs>-skj!3~I5Lu7V60@%p@w4Eg0qf@dvh*sarV!yoykMoL#X(NdFai~@V z@GB11_(Ks%0FFh+EaR_UDK5N61gNGYdxR`Te-&p< zV{0U>Cz`~#$iTp?`;A@;)Rq;3Xm;R+`u;wdtn0ai*DdA9$e`oPFSKnObovikJ&bNI zXwHh#H1fhJD2g`j&r&Mz`#puZm(EZ@$zp%cdgQd|FXX_DgD&oP_Rk#CZtQNE%=X3I z$-ykD7mhgmsX8!n)M})XI%xGPNd$yT^DqTuVT_I`me(+)+QYPYyF`qDbDwJEtZ)3A zuPRtvykltc&jZwx(yzX(?{FDo1&>GE2mt!nemCgC})`sM9xJ zvA<&STma$naBzPw^U|pzsgX-CM%|Yg$TXUaSD$5XvBsuM72mJ`26Ou6vRtgu+-1b} zAV(WtM6Ac=DBXX_tgSCwgk7u;H<|MucVv!F`TQ!hXUh`BKa^qwDF_Jm{{ZW8RpPX> zxh(N~tWNbDk~#Iqdg)P*D@?)3-stFWd{GI#xVBJX@_^)lmOXp>XY;Br;@ikB0zehf zfNz-NXgxE}(x}Jb_I*+_JVCY)a7j1=w?5R{{{Rf66K;d%+y+h$%aiR>4`iPxU%^qLxe$Gn{gB{(b6Od#y)v8;hlFhnT<|_5OT*RhgpM$7LG5!=PmyN#_{n z^R44~Xr)&vl6kIq)w8lSjXSHdj-z=zVl(GNpEpz6)Ah|mU`^b_$#RkqLHQ3H_o}mB zMR#|yGB(C`s*ZBG#($k$)3ym@@|9C)!65Y%rB>0^4MSZGC9)o2X)cQ^WMBcuukxyw zxl+^@u!_6p+_Ni@tjf}V8*E)#Q>bJ&M-Y{JyvV0m=IZ&$T?=+ zjDM3=?Pqa&IM}Wh)+cYXsxcg4&V72-mA6RY-XXVnQHkRKj{fz}n`@U1_KSr{3YI(^ z(zMe+e3~V{$-l*GJ zAhp?k!+GjK#wjDQhAE8xX=MX$bH~=Ol-=|+Q6=-5EQLVJ(;#%GME6l6$noQhFSS(u z(6_dBS7q)$D!T@)1d%Zl07>tTwapoGO6i(AC1OXtx-f21;PwanD!r5HQM{gffsWjR z(TArMZY$Wv)saI6H3h}m$1dayNa)!7d9H;~+Qx1Q_a%y1X1I^fnN?SyQHrAC_2n`& zn2mDIbJS$uenUTvRf6(of!xLmDc}LcLH(g{*3zex{$XRWNZ_CI%|3Y|8by6dIj$J5 znDK(dfz(ya8hgm3V>?LsA1)KO&|;XE5=8rE!?F*bW_TFMtr+z-`!h{%0cHda*)_Md ze73PF3ila#s9(%NTHM7JKfNAXp*Wx_)@*{D~-`+N5N6+o+?D|>^?u8^OY-{WoBgM5tBmeB=hCyD7@~!mUzZukCablRn7-!1 z3C7;yo2>1iDr>2#+Jpz@AoEfSxE3wld*ZlVQtIl+{_JiH4nXw=mq^s_E*E+A)?I&xM%MFgx&9{&@l;uI`Qlc`y42}rrJQ~EbyMa^_CRB`M8kFkrDaJzra5G6& zOil!vv%?I6L-LW(=b@-#yNc=q9;!6P63XIKV#jo3bxb-O?m2fV+zh2=7?~R)Wsw%Vc81JGkjvcJ|82_n6>h6YOb5 zonMZRT1B_NZ{+|p7&tMWm>Bc=r@#kLWWv10AeWnM7BPBJ*jtcjUb z0p(p!Rrl#kn&-_WdUA1-k&kMj_Mm_gNh*3C{b*4pQZ^E4yq_^nKwuBhdVW=-1@oBv zvZYLimhKO)^Q@gVaQhL!BOC$8fAjeYyEKtJ1yhVR7m@+>`c(a^4LvSPePJc!I|mR2 z+($v2fBL^l(z_7sV0jxnNjB}Ay zTT(k;=NTg;W36e;H?bCvQq`5U#k3D0!I*rYbqC+{t!yZd%yYlWh&yMeLH<9jbL*{b zg-1+x&tF=-9Fd$ctuqi!hFEC})ja;JB;2S2YLg=1V4}T_T*o0+Qmy81tye7kO1AO=a^hq-Dp!K1)K@!w7>tydh3AOJU&gbTOs(@qRQ16GpTKsn zQWT>lsmkWlJt{433DoVB6)nP?22;nc)~C7%ATzXpgwM!NHRRG<+zD1i%9Y9IBDAb8 zCu9OiWF?Mpr#bp_N?1!PrV72?j*{x=#uP-YgX!PtRIXC$LM56x7^u&2wy#-PJkrL? zxs|@@JO%bOsXmn4LMwq#58YlDyZ6w3C`}d9o3T}GRRkQgMddO zx^>bqE4n7^95XTDJ^uieOL3;hb^(o8gj{5CyWiYg5(&S;{Du;`=@y~k>=ZK4}QRk%~Y`?&pUtzu!zdzd;hy^dli_Fk)i z+gW~6GspQgxo;5ME^XMxMmGSt!T0v9HPSxO5}1_`fN{9vJk^-ANo~TkR}m|J5M1y* z>p9|L(NUt&m=SK|X*Vc6kRW02k4i4>HkBe6oROWS0L^YqZ5H+NqEdPnj2wMWPvufa zr8LR0F~K*CDPncQJ2SS8HHlTY;QZIchzT&fQ*5bvd|$X48{}Zl0WV z9MpPtzj`RUU0y*c8=qpb5N_cejPcP;NcHHF#KCO)F z2+lHAM_H#zC9;WbJhTUqux;lR&+BoEiLi*QfM;=Sq#weWY?_>K1uWiPNnZHRr{z|n z((W$6Ms{gRWc<8?*mdWvV{LD9UWYX#<4%`5*CPrBe_!QO*xT7^f=MTtBN1hroR;UO z@~Nlrb<~NzY1Q0}ka*gC2j|wI8XH+#$haYi83gtHD{H|kr>U2``e<}ob)AjWFvQp; z`6wIsM?v(h%iRRXsBNcYm<;pKfzW?C&PrBasQ;8&OZU}M!9@TCS323(0tvA_Jf}sXih4%upf4AYcxsjtq zSsB1>qaQE$Q|H!&&7y>nTrnk-oa3kIPue>NBDtq_mU>J9ZS50aA2WLQ%|UCeTiw9$ zEM_SS51mI*{KZk!?~K}NK^X=#2P}ga?Vi59ezk`U`rFT(sF7G9E5HPG{OVk~q1&O< z+ucE8nUa4tMtto(J%5!rUqx`@XrYj7&fw?e`j2YlE_G;F7}TKTo&A8@*VeRbZ>`?V zBbrUdZK6PjkT~P(ik9Ra>2iD3SrOCsP`dQrjo#zy%|dRiUEDOLR|*t2U=MGv_*QR; zt|69BH4AKCmNebQ2XcQZ%+ljBpEc(Ua8BRHofPr$Wx0XFd zPo_;pV{7(&Gsnt+#2!LpXepMn(syJ-YgLuE$RBrNarPofuoq{;U}R+w5`Q8T_b}Dbmv7Qk>3V zHH(IxPc??u$t(vX*h4a{-Pkne(f;2PYH z%Th}i*-(U$iAT>-(>2}QC6%rG5?pAFB-4i*mm>|+7_A@p{g6ckxVGBZ@@5-B0|fnQ z<%+$u6lhxdo>}JJTFPN$IL{{?Ykx}p?ClF@cwdzY_1W^5_wxg0-)nR{=e%^ zHxtE2Ix&;JhlhplxO6K+d03s-uG!g>GEbM+_3Ge7D zlbIXxv}8b!Iy8ixj(B6xH}ucFZ_la3WQ9KFaA}D7 z7p_0gHRTt&td|!%1~#gL$3c!irBwdbylu>lxRJGX^if@uu##(28Ddq>O4V;|&AbLO z4&#LxBOo7M{c632t!n~1mnDcSpmZ7U_M@;=H)t`;6)rp>LMm;$1@6`VQjZ3FdyQE({ z61C2X$HP%uTpN-ll&*Mw=Cs^NCBizhDUmr}Ob=hixY;~*^F=hVs0ki+joIpIou9-P zv|_ihF$Dep0Ol)IN~6`IKWPQj?Ty5731N5)yIc_M&tH0&-Z{4^wZK*2D9_>bt|r^X zR#*4REz1TY1(k8yrP6OTh@L?>X`=JG40Pn=ds6mtPhAG57qP!{Hk~rZ71YK#0m%$G z_WXawtH}l{nq)=~W@wa^~&y#D+9(70C^|y*}f_Hac`M$hM4%U4T+L z4mszqf6k@F?21ip$#nZISuP?^v?#WS`DHePgY17g=pkiGEX5-eoure_M_R_wd{bqq zT4h6ih+yz{cPjS+-t<1Mtmrl=SEHcV1*nLx8pXt|sd<huIyp3-952fdDd@qx!Gk8^OJ@- z^v(@mg68^UE|#*u%zVcsI}Bk?f6oT8{@ZqjHI~sDcUC*6L&3%~f!m+ft<&Zsn#IxL z^LCO)8Db+OD8c!$*0FB0D5uyRZFcu zL)Dl{n;Io=-YWMzaf9@%{f#GATj)0`oSHKte;-JJLkV6Kex|cD|BaH^-*u0VeB%F8S_4lgUc8Q?rck+n@?P#1Y!Scg)J5a2R!}q751;+TbjlqVQ87 zj!)y$nu7C0lUR)=wq1z1RSYtAkb2^=oFk%IBUs6;cQq#Qc!C^T$Rx`JQ<2Xc^reSf z^CE}LkUY)_ARL4qr2bXPH-Yt7yt`PXjhTtxk8A=*C_y+2yB;oUb;(^Z->R7%Q$SYY*I{c7DfC3vt?o%Kg_x^06lWIL1{!~^|m zNH28DeX7zf;CRXBALQ0j#NZ>jV8Mpqr|={7HDX9%m7`RM5F6$s^Vk0XtytOLLro5b z(V-6e6a&FH6(`yioZxpNsX;tT!l%q~2=t|fc!Z4Kd2^4(w@%8&ZC%{I6qBfBa1MDG zsbr9;-M|>`YLu6#kTU`cASbVWwaotj!b$d<$F!O`7i-{UP9zxr06hCsbGC%?UsI|V z&K0t|KpDw2i+L+O=mH4zyu`<_3S8R?Vl_*L6oRy&9C&c^3%&_T{B6;{f0 z(YDtt6L);$6%t-aa~nFHs=e{XDg!Ry+la!PnvUJUjK%^gf_NP%xwgchh;FqXu-Z#G zV%X#i@m%tF>c(PNN>z(sWMd=LR?ep#n_2{(;Rnr~q~tN`KbPrVe}AIspJ-=!FpACd zBNN-FJY&6JqVH)lR{I{4rrt+)51Q91%Eu$n){K`B!w%i#ZW+lwmE~G^Y4vX-PnuY* zVubljPIAC?JaRwAtleJg9!#*oF@Gh(hamjyNgF`)&MTo^Xk_g5J9zv}rupoPbfBrj z0>gv;b5{QVw=JD_tcb%Mn!H}~MQt!eb#W>ET&lGZAS3~ErI_cfvUp?;K(N7{X zz#r!oQrA|3%J=8IGPcq}ZpZ`Q9V?Q3F8=`iYe?xE9lKL34tv&~m*I(g{QUf%mO`f( z!0pGqHy9M?Gr=iPuDH?7Ym~J{e+$Sey`7p^)bz zzCRq*sPx-OA#arfb=(Kd)83gDn4Wo+Hyo3l#GKZ=5pCO$toSvQ>bCSQG}W~$&!gMV zY*kQhEIIb5t$Z|!j)3i7GjPYT;;enG;S5=Dpn;Lc`RP>W@ibP`Y%Pt)<>#;Y;*@JW zhTw+Zcupq0GYLLMaO@u^obm-qnmx2j8#;qFbDnst*72>pjK47hKgGu1^NOvgc%CU? zK3u_D9dpvIPNVKhz-W5{ow*w$@eZL-+=ihI5t)`h| z!<@=8csz9dD+=FJ*R?iiUO9p@Y(iAvka^~&G%C%u-H|e_2-zfe_lC+j#ECN_GXtQ6N_fJv09R)}@f?mV!0&7A82`vQ-9`~2lgwPZIQxeukMrqJg=uc)MrD&`8QeBh5%uH_Yc;%N zeCBA;rHz|v=Z-(lD#Kn`+}T|yg5%DWGJa4A9Y=n7Kdp2^5?>NAl%n=!?L{oo&^l^S ziAwMRq%g#9+{p)(#q zju)u<)vIJke{=*wEx&N459d?CZEG8=Z2^>EcH^yaRg#>Jm_@}InuU}z+_TI`Ve;O$qURxQIt^(}~f;!;;0QLU>T85ie zMQF7%^($*#LC`CelNl-w-U0sr8nGUJmq&E z=xXtXWt_!4;O=5fWMlID&*fUpu0*b98}nYq+_%IpkxHQhB8+l;uB! zwF$;MiK0jz4bt2Vg#BxNXMte>qYMbju2R4n|6NKZ56&h8F!I&)PV zPk&^-dj#IUDCe#^Rz>}l^|_1e#FcOEwsHq=Z~p*Q5rcXJq?V_2X0()fafN08a^BrJ zsGb&$yp%kXo(E3mxVs0xwY!mIS4RT`44vNp0H5-%irZ9>%^EQX!|!h3)0`R z2lA+l9G#I;l1k>}@Jn+dtWj=-i6pV-(wj6MQh8-Ik94ij{DqaU=uRfn4^r4Cw<1 z8w?n;IbZ+-x8iH4xzeqsOu;V0f^rUfRVcK0@#V-?M>q;3?}6L$H58MKuEKh&91Wj{ zZ!KIbyYQzWfX+SZM^EvD_j42lqlg~6zbfwF@ZOs6#_BN8`V8R3? zNb68baVTfqwL+%vz1Oe!Ry?=QXBphtApQsZ;%X!jPaAC~OkE(je-9M*cn zbhiz-FbpsQ91+u}ze?(+yN+qM6bmPOo_kh&?(WGV6>`1FOCr~7q1+_V~tSbIUf0|8imss!$<-@Ir)0jPBLt$wPSKM zx7bl7Rcvm-u6tFMSmbOnu)*LSYO3En!8fC142I7pt6jWK8PT!EK4K`1J3T?l=*FIW zoyzBNKXtm+b6xH%t(D^Y>lzAI_LDC%b!JDWn@ zNeIHW$bdh1;GXq%-eKi3LkVe{JTN7fj)T5spF{}t{lWjM#o4i0}h&UlVZY+PZ@p@n^+yJ|+zMm9$t_RDwY{3_*#hc`)u2_DhP zoYvWnFm5iT!x>RmIrhls^Q8r2RY<})bDR#OAM$HB<0Ru`U$KquHp1ZPk{IO-Bv5@e zkydBaqx19T6W<7W`h!>+h4T5&3&$qk?-AeHv*ewkgL8e*2~s*|)7qaTrKoe;L$H?O zDG?*w6R}sd zH!F`fD+}z4W43Y~4m0b;NN$|Ie3!;@OD9e}X|Mv(xLDUD<%k2n>x|aDtWMFDk(I~? zZaY?zs}v;$%zKAfE&k5&zT!b4a1>QjWj(9mLwex){e3H^SmH@GgaD6jzgnrPyo(s} zh<3&l1C#hvM!!T3o|ifO^PWp`di=CfnJ%-;5fj{={{XEOuQ8pDLh||GxNJznf*G;X z+NxV?GsQBL4snX-zqRL>m;r1zIL{uLsmA%? zW#p0R^{Fj%d79_VjZh$L9sdBzxuZ@I_>G&CwkOi=??vfC!G<=F2X6iI*ZJ0-qv9rx zG_)~3Jj|eCD~O&#Gq-mm+O#Y_8N8AQxwu%)I0ZQe-_Ta%dRp1PpKbfN$-q+F z{XPD*v1@&CwLoQYjz%+&rDyG}v2Ko`Iuxkn4IK!+X zk)8*?TIz0Oki=3_$b@CKwmIxG-m`qN;fIyGY1+GwA6!&Uqn71D3OgM0-nv{5n0$(G zp!W6sOstu%#k~Oww?^bYQ?@hubTyx7 zZbhg`hEaxcGEPs;`sbxsxeaO(S1r0uNazo@;Zov;q{yx<9!OSsK2lYV<>R*l@juS7 zC7wtJma+mEZ7Z7SOtajAvPw*TPz6Zu*+=79l4(=D@E$`TUMH1TbEB>(4*T{uOrC&+TwD46f2h z`{XD126@5l$MULCNnMk6^hY@)S631~$l1{RoMRyRRoB!eu^4_BWHC-Q@%r#TTJ9f1 zg%TGLn3hCc>Ki$HeecWpS0S(3dH04$kr>G3w)RoR2mb(D+P8&B&RnEQ5{kKjHlr+; z3<|y&_v00-Ypf-VEWh&6)T!gK{{Zz@IegQt%!7MKRNyce=b!7EuWxO2aU$(j>D(IX zbYmr{f~h3*JBT%(H2lQ^4DN2=W4H6I>s@LYpkRcq7ZEQfXwC;try2a~%GlgTyLz_H z_~V+M(^0#Lw?`{RdlA%DGQuaSG+2hWJDDSkTE8%P66`I8+qZLLx3zCKfwXA|SfaXX zh{jtD_xS8F@7Abz8^ktIYBDCXa2bgG+?#;MJc0=8UW<9G>G4`T){-P)h6cfvZ}ar5 zYAHqX>}wXKuIHNhucS=zLena)M$))FJNi`Vs@!i&J6)~jHcMxMPd!KDSMK#)Hs*JK zFU)Cx1xeaIw96}HdA`y1WlLDFz>JblZk@AS?lxDFHBIb_S084c_vaF$7Ub{egVUas zejg}9D=o*Dz5ZtzQd_TY$MH2C$h4bLSs;~ED8?J9`j5xnvnRWX1XNwE$vMv%^{8#N zp!Ry5&4uAha%PdG#Agh^@(1%8Fm>y{SRJ*{#CiA>sg+AX+)0Pf^Y{<^ZL|J4&(5< zl^WOFn&!mwa}H8JyS2w84Xvq%$w$hlD8PsX2P z98Qr+%p9-J^6)_iJ--fX7^er!%V|qQaB}Fk5WI-${$Ns##{}mb9{qD$fAEaUWv9gL z3~I;a9FpBf;p@`95dDa}Zt4*186k349dK$bLVFpJ6gD=3a8FM4(D71eg+eIv&+KOt zTge)T)wM z6UArkXH!DCVGT`}h>KFuu@L}9dIP)E{WJN}!D$5c3va&?0f*Q*VgUaDIrjIiUiZWz z7;yW%ob}29R@#IwMM5c#OlKK8>?wgeQ?4)UtoR5rDaoX=EE8Jivkpr+cmWonRzvG~8Y z7zR^?azQ7Yb^csdW}~b9isu;vpW!{de_Ev%ia=eA{ITGJ#ykH2Pu95JB6TNYp;LrW z)!k^wz&DwN!OE#T{{WoUdGM-SzWb#NQGQSkFmqI2#n2g15x@#@ocmWtXRE-+4#RhJ z9GccQzhY&}Z3-418;Z)*BE~`752*u_kEcJST!TkY6+W zdn=XNKxJnP+lSuAZ_rhH-4gD5*wV)Bt>fBvFkYjldY4JPUsAc!(F{R#32!hH^JfeG zeZ^mk4sy|{ECve>#}!ms>ei*4-Fe?H++_d*$2rHKKc!iU^5tYmZV?GloUi%%(4vqw z*s?k?bzs?3yX#1{vpG{5uif3yb*X0!DP~{wg)%aFp5Mq*;ejmVX-tgF&GN2zAO5;Z znz-EA7xr7n8^*1j-A_(4RIWTYhBlGGXOsBHUuwQJ0p=C~fM)=M&{R5)h~C~Z$!yXh zfq*)`>d*+DVH%q8HJzqm2{{Tz6l}v+dGKlsO z8xUCk0Q$ckDRiwICE%XpdogmX`TidG$tM~9bu4}=Tc#34ZlnycQP&+Ri};%Qb&@FU zpkR-%76fkOXBAeK!qaoDwzIQ^Hmau7T#|5c&+@B2U7Qx}Bl&Rk+B`h3%>#XN5y8&4pT zde&9$vWalfB!enPDc{<>-rH8V)8tT)xGx}LSMm1$0648ZBF^Jjzj=;4wCl;wq4ego zl|Eayu`!+WM|77WNR?La4Ja&wAaT!M^V*UrMXkJKqc99GdXeu`tn_H@<_C0+>US%b zKPVU=b?K0OYeriOJGOXA^RyfeG4vzrT;9?*vNz>@NIuwSV(BUK1_@OFkMo}1=9Q(E z)t%!3#^L+1!zm-V{EbNR!(|(!Q2gqrVvaX){{YuNoo3(en%S4iZ!y5mTcG~{IQ*$| ztA{JGxnpq~K=R7#1F;}0Hz1tjJo;9A^Q@*}9nz`*Pu>KE#s}rs{{YuqE~wHHnShA) z;a!UY4l#}h_oy~3FvQVBTLUHMW6u~k=im8PN~W5*i=CO+pAp)<;k8im6;(!J{5E*w z>riUit+Zw{0&R3)g`@eika~ZgsrP=+Q%RidU8T+K}9WpWgd(+LG@)#-RH7f7q2bZa_huVe`PYX1IbZ>?xPKX+Xt_`SF`bTwY|E`mKfb3kT~OL z80+hvYOb?kZX)unWfKNn;g4>EHEldOY}R{j9XCJ9zPxq( z`26Z!H$t|sxN{pujPiw2q?`gfe=owJN)~0>cSd#BhV?7^soqQ1^W#Nf8b1K?4;jy= z=T-HcH&M2NDF#*~O{}Px&%RIj;=8z^g4x8pHN%3tvz&4Mc&bv}TSz>stAgJy^BW$x z!Rb<}%H=v}^XV^Uw7HH3Es&$lP*`mz2Y?9ZFfr|0`YyY7aM8wz2bNcY$=n0aJ$cPK z+e%xj+lluXH$DTC%O75U&o!hphqsym3`!zUKsgy1=kWxe(zTqT$%mcR`{RL)Dmg{#27Of? z7ULWobnp06ZY=Jii4x9Sd2U;i)Mq&SsoKlU7M{~bIVDt_4!t=3l-)@rE=6-$jfc#L z5FCF>sMpY286+bEB#wB%?_OFwL#UgThE3s^?f~`1as2Ad-mR(Iz-72uOnY{OZUG#h z@+qiPlhqOJAeM)Db*U`G#|grg86&Xc{{XL5jrD`fByGN61P0FlcgXM3yvlzNYI>w$ zE&RoWzVfK)jsX7vKGnHrVSgpAJeS%R3(hu-WS@Sg^QSC4p{$rH>RKds5Z-BWvdH*% z-IdDbtsAHnv9JIL+B;V%q)8MXySWUbaK_=#^v-|!^?u^*A}IVUY%l@N2&`u&v^9!P zQ=zt-&J5B;A6^Q9>&HsC)5X1Z#xi?j9Y;0KSWKz8W0Bd3Jb|3m$GB*nSs@|6zm9(@ zN=0&)WM~#3p|&vL3GY;9yO!Aez-06$wG!sq;v|;<^Yb2@`_r`xcrH^oR>vfcf6say zK5bJMHMBYLsKqQV9>cpJl1>2h{cDZ!M2gUEw#&9Qvw?s)&-hnWaiv8P%8KklB1h8z zg#c&ts%o+MO&qaC>Z5L044NTmO6*fkQL*Irkl!#_B3Vl_@_Q5Qil0u?ZzsIjb>}Dt z45hHy^ya;G2(-vFL1sg@q3nM;WRPh_cbVgiF#wm_f_)G9^{+?kx>+NS>bl*s zhMl2XI|yZkn%+^@a9{_hKDqR+llwN>-9%BRE04LyJ&jbcXqqBpgrs@M!yY~A$#*EF zpDYONjMtx1qw01-32a=JGzKu3DmWl<{(IGF78O>OHNip;1GP^K(S!_77~?e|cpoa` zU?Uvkky$30qtK2y6`_ttQI{M5Kc!b~DP+`4o>5Y{1D*-#pU75%TS8GtZK}U?uRo1g znn>dT_l`yh{WDrMp%>KWHBSylcNbE;4cO+hW$;Cho*GThwEqC(y@o5RxVbDFV9sze z>rj&6LD)|?=fC;plC3DKMTx;nR*Z(yw2O3v7-L3E6)G{(pDo>+$OI1#&~QK?dVZCk zug5z@GQ}fr0|1rC1N@)HxG8j&XWTvF3ij-OGt7Pk{w$jc#l z6^6s?as4YdR{Kr0)L*)30;0%3QGv++01wiqZFOz!)?=0dvH%?5(%EaPsa)X1c5NzD z_s4p;#&+gthT`-^yG!?AVMJm8!8kb2r%o$A??kzs^;YeviDpG5 zLV=FBB>gK4&wn+#~3}-usZhLxjUA51L>~Eo8HU(@R0VE8L+*WR( z;ax350~!Vj3k3jRk}+M>YSG%p6)DtO+{(A{RrJ%l388q-6ckOzujigCrHlJU>+Jsk zYbvlGmxaMSvz+_Z4TEWVWzEgBDJ#zMWUGOUjEt^2=bFBJO>c0*D5JQK%j6c10QV$+ zKc!t&CjG^rpweFRHR6KS3%@b$!6*uqBz;HHsp_{@^315ezA`e51JHB+eznZ&7HM+Q zNojfuEM>gDMo1%}?lGUpRc$cc3#5@|NmB!$KQ=lJpXU@tj-1yAS6*8iQ206tLS2-W zHEv4uY$cEpVk@z+RGpFo)1kqsZOMg{QP`|Ldo02v4Ud;2)OY;rA5qam z-otjdE`W?5u4*VeS89{2R_(b+$0THN{JK+Cg^hwkX3lD*HNvgZ(NvBe#Lb%P>+& z3`y(B$K_iP+(02Qpcx|r-xZbP(7Q7ZeI{$7E#f#12n?ra81$_8v?=W;SxwV2#hmf? zjsX5+KaF(qNQ;TLT~Ct>vn-IIVbeJ0kN&+r8+%w6XOO(9`F8dk*0+VM zk)5S|Sws6y6nPl!UA%$yraq%+Ci$r9EKKe;W)wX+x#lh>rh7usde?oal!up3i8{nRzWJ3 zVyB=Z(yK+QPxjnJx!ZRfbDElXDw66F#Km+yeRUX}^XDk+ptnj{GdxY1RG|kM>)NO$3ItG-5!h$#l*YmAgZ97_(g9h0dA&6JUU+^`erOUeyX?}*Dp`;7zMksM018FC? zt_xD|&D?XyRgaW83;{fm(!1Maw@ zpS+B!T6#0hZS;+5%I-9cU6HVIr>OM$*8P)fc6Sn5`7+Evz+et>lh3#R0IIzj8yI7? z2o*W!py}3@R#4t_F)5H8t@Nv&CAF+jqej~^&-DxKYAEBlia8M%<$U%z>-6XJq%dn! zq*qg{trIyuKg~exn_!3l~@Cj*#0$VZNHKia*Q4_JM&rlT{Ma-lg#5Syf+2J zD>cOIitF<)TpG}i!*;rKGAt4jgn~UqZCzSMQzLHH=L$O2ST2lnNffZ0AQ)`%ipF!6 z#l|sOneS?`y14n3KIkL-`qp*e%bzt}kSW?mcMN)0Ni@kSmJ5W(e|pQB_RO;RxZ{iw z)BgaiQm#|6&r1}9tE;}iHmJu@)ctBH8sH6*40hd)0IuE$?OPHlQy<^GzSXZCg@u*ZlF{rtvPmCw^vJG? zn5acsD8@8o^^whK{uBF5-fMl;bH5+LN3W+-#dJ3Q7lPd-K%no#0v!Hais<1MKs&%! z406~#{eLk@c&j9NO{IX~=N0GF#MGZtsx)B}jJmOgAmQ1g&lmtO>Hw+}SqP*7UwZWP z`kYqH{kdWzl0`-w@Cna9O2(Zg+73Wv87-bq6>yxkY|d#FOzUrq$-j<=f(2N$)d+rD zk@tD+?^!plc7`WBa)14GnI+GWD8qG7eznycI;e~tM;3Mqu9kI-vh8dV0OK{O3EL6! z_K~y#%rM#Z{cDfVqL)y;7*T~F0(+YDsC2lam0Ta22LtYbkMr$ZmFY&5)KRr5Ijfx0 z>DO|dtsI?lH+4Us)~U~@v~s_m3Y-=S4l+NLcWrnihwQGKa6kiK{XJ@w(0!&f&N}il z+dTa$BVI|_mg%OCJ)KrLSldUn_I#zfd;b7hZH3J3FA}dO`{ynAR^FkcLYtIG%FI}S z*FN8^W(W*ETz+3}Na$(!$?8M`c+59g9boDMZ8PyxsLzyKj$?e*zUR}4^8J0zpj3@&i zr%J_+Nr)&z91cOP3vE7Yk}gi?%H#px)}c~R)v~$U(Gg-!@{IogyeO!DehxP(`)xc? zTXLD)?X7e@EZ;rE#^OmAqcQ3JeQ3Y%&4uf;M-j?4;&4v~o;y~Sp9k+$&w&!0u>PFY z%UR)T;b{=eW%oJmeY0A|te&?i!EAAJcy`L-Z?kz0tfT}5Kmc{)@vBjID%Mn6NMphG>#x4ZKY?cm@Q;CtlObb84lrbh<{YVpVC^s9B`x|8gq*urfR+Q;XF z22?oDtACu*v2?YTcfl$_3OfFWwLa$cxtrx9KQ2E$MQ7YL{Gg`*a(@c8nuM{&LPT3|!j0Yfo}cH6%C%!Oi#%Kd#v23= zT<5iH+FXQ)290**fG?adBcTJo`Sqn2%sbexbF7txOR+DK0`$jW{(iNmX{g&xwiI74 z%K=9`cO=&hu3pTS%nPAKd=i}pUIkRM)g_ARFr}4qmO12rbNs7cV$!*vwbsX|Yg&($ zWU3uc2L~fOb?4WuVcY8w%MfVT=lFT`{cDlbJV+(JF*qU)>_%$1)X^VzJ9D^`fB^Ks z>G;;LqbD1*M5?6pJp$uWgxePk5;4F(-#sz6? z-F&b{?2H25fO>IR7P_)D@Rw|bIpevln~h1OkybDSTMIA^o-xoIb*Pe*RkkTOw{xVi zp2}xk^G6!4Ko}l_JboQL>W7LhQbdeF5fG+I^Vb>A^R87|K|b=#asgk@^7XEs-t*3Y zTgn$~fCHBAk)P#Q*+rMk2| zt7Y`dV`!@siMW#^keCP1ew9Y!O%``CZ&eEK%Bvi|eEvi8q~@E@X*6@%ow}{6`It8{ zI=O%D1sKQUpVF;pcjzu8o@O}m&PF&VfHPRy^~9-twh+r3kCYNRejk-`mm0*;600FO z>yDMx3_Pkt!c~+cdd{J&+s$DbLU!jMoafiM?TY8@rV?Eghs4Xn1#cmE;ADK1k8UxtHAK9&AUGc=k%FY6xQhj;HdL>KQXf;1+sf}&nhz6%6 zt`anrftxx4QWlYS)1?jvC;3FL9d=}fY` zyl0Wfc8P{r#{~1x9>$cFMzv#$f_f8bx=GY;e$QhbQ$H!jaqsSGt?z*^EYZlrGXb<` zkPoeP+GNnByri?oCPsJTkMo+xR z(8Q9U1dY7o@g|>f5VI{2fU^P188-kuvB9p+MD%7n%^e)Nq>`{fBr-}@0iwtXJqAGM z-ka(PHx8tklr=P`!r9%3SFXKQ9fi1SF^>Q&LlD}q1I;ayvJAtQKU z!^oozlp#kRxg7mPbhCJJAMC}mf^DjVHe2TRAXhDF&UWQGDbwY>&R0OXg4oUF$Gyss zii4t(f2pWr@R^rWX+$iBLPG`Z>C@NVy$4FsZ1ih&h$0el9QQottyndu+UHCX$T?Ho zRK+y(dz9K}<>Byz@i0iDj3G=hAo71dKsl=s_-5+Gw`4k%`IN44$LG|3wc43O#zaGt zfrjFq=wwb<1L^oxIw`Hhs#x>gLrp7bzjGv@5O6#CR}rZB_KAWrRFTL8VArv|lF2hE z0QV|!&0^~Q9g5-uED%Q|gCNGhXZ-V6I5f01=1lSVH528rFNOyS4_SPI`V{t#m2i%`V?cg|#R0?O!*9V6$f`czeD=dttPr=iLJ|r^EM$<$S0+3_@~3N zTI$yk+s5-Ld_q;YRn7)|_{ZT}J{It8^ujT8jTAUCtA^{r8DDXcUW=&(3!JJFavQRM8}d#;RxEkyc=hd{!o43#@r{+!Dv6?wP1p<@JHCUktXsbZTQ;M%+D2lM4CIUf z$tNF)6-B%YExb)MY8ZKrMh-Y2;<=>g&&iv`RgaVh+?#i3^sXo?tYy|{{XJ3*lW7P68R8MaVw@lR&sDE zKB%SdMV0l2ourPo@4?#K&~A=Y^8wlv^d$S%j*;;4?(0vP@0H+~6?0oQ!&N>0K!C9NQJAkfZLv$6@bT*~d@Fy&k6vuXqOL((iSjnIu6& zmtJt)G5P+LK87Fz#<}#BpItIXspe=R69zWp#5Tva%yMQOjWCJwHCYR=K!{D{fTd zZ#zd*{{ZW%(_O)C`&B}Ka>#?J@0!in(Ojiv7NXjp?;1pijocA|+XMXfu7()h+wKrR zILOH+s9S4R?&XXj0UYD4TwPiwkwU2|*~hgJOSm@39>Qo@q!%Q!5&%445B~sF1|b~r zt2XVuN)9;p{VEA{Hc1q)8(5vJN8_K?k+lfkSC4T;Q-YWSk6))W^bJe@0BxHE<6I~t zDE?-%KeVq|GqWBT@OU(w*!fXz z?@^VdV;h!Izb|fa{{Yvf9YXo-Lq?!7fw`D>$4{>{6}{{}TZfWAG>{pGetHUmZGO(y z=gPR5(MJq+oE(qkfm3_zJ6ODzH?T(w&T}gOI^#L#1MsFw_tJ!A5+kS?ecWdm{{ZV( zB0O04+PI3&Hjy{sdhj{z-|JRSiLP1Vg)LoG=`L^5+-{jeNXIIJum1pAxXG@rZ)akjn{T7K zU8Sb!TgZ!ka6m7SfKN)<5Z$bZ46&-?b0V+xJxv!$=sR5Gje(k2HpuqqP6NighbNJa zokeuIW`!;0-?XzTtN#EF2JdtEnyU6}Wf5A2nTgyTfIChzk8W$Cwzjy~kuxI4w{Zur zKTa`DRUL&GqbB=BhFIW4ji#4)+8RzUIO+IwsP42llH~+eYN1^0F@x8(eREwZR)SXJx10$c|kbj9Q4m$>r{0aG`I{9rMi$Z7mt-e$2cG7 zimPR)!xg00XPh6D6YK}_BC_VXj{VxuDB2V=KQ#z&7{#*hyxzmN>lKgv7jipVU^1T}h|N(TJpuE&GZRKqOY5paw)B zxg_T}_2_zHy8GDSnf$ndrq$lc1~|_L>Fw`QP9UBa2+pcFI~a`Ox>ai!`!vpDPSEwI zvMVLbk;n-kGY?)mdv>W~u$@^=#P03YhnPqs=xcJ{%oCTEaOMcZ9Y3tN9GZ!E-40UbxNt=LRbz>Jcv!V6&!TJsz0Z9)q(k-k=t0hZ1W z7$44=X|G+uFOhB~XY&9UI9_<}I#zJzmZOxC(Vmd$D#B6`fX&CXRg+D5;Sd2i#(&hg%m=$1EI1bJSq^noh+co#maioFFU+SqUUyV?DE3 za_iAUI*D3eF z=clJ%!nz>~#_YyYv(W0={M<6d8aI}}pEJ7;Vf7-a%YUZZ2}RAr@5TzAgOk(z^rF^i zqjeHGAvs!2v;VO#i83t3sM_O4i-IURa?aoVkFm-D5;wY0Vpz>A4?;C>%k)3(ztTH9>y z$}`I6pYzl6r>31}3zQ&kRxP`xeSW=ao7VEwl(e$Y!;VWt5lM9$DaLk$JmljT{AzZF zElHz_G%E}P%I!)Jesn(rK8G+se5S zqNWKP9*2sG=HB9AyL%R9!N))bdj9~P)x9m^839Pw<|80_jtx2-Dm&qFaC?8Bdc~!C zCTV>P7%gs=8JXCi``9h%&VIaBP0xvE)9z!nk~ZAL5#Jyh>2)1O-rP5tGAm~%j^35$ z9x}ZbcK-lqw_v479D$N^+~=Xs=~~dG%{wzH)j4Byb%Rz}%xUH(2>F5Sf#3Azp}B(I zH51(2Dx-X;6yZ;E@BVqOB8vA^wsn#jj3IN>pX>FjSGvXY!Zx}r%%B2C83beVuIGT) zMsodgO;PBkK{d=a%Y_C0XOH{1l>T+x(;D zWe?Q*_Z@4s&~Gff^(^kL?e|#cJvr;sipr)QRP{!b>qchr#8C){#A-669+j7Sb0lI< zB$o6!^z^QR@loxiNWjAr#&QU*a!o2o+wC#7gZ(`j~D_YURDv4O< zsajBao}&+lRHJ~b0y}g=H;~l6!q?#$wjkMAEw!DmpRFdBDv%b=jjr zrHR7lNG~& z#DVj2D{}Y5mnP0J1C=iOS%-7f{sfazJid2IZjFjP%WH>JL7h2$fL0fPK<12iC2d^nl_qmu#LzRMan^HsNKM zN4u`?nEqYA8qPI&-*Vg(QO;lLYk6*Ba?!h;z!u0}nf*IeO+Ltha`xgvuON+ai~xVh z{OZ)v*u^|-(&98`a!Uia9CgRj^sN}RT`JDh$_krVH zhG`Jw3>6(KIn-%tR8qc%t+Yzy8N$4(N6piAD_8(jFBmz&^sa5S6^)KY!Ph7CsBSfd zw<197P$_P`FhBbL0Ht!Nb4tkB*(0PbjS-2;k~`ES#}4K_U5*#OO6D}}R%xe@yo5&0 zgiGT~d zQqn7%Ykp?qamUM?0!gmPRY~q(p>?7v&t+s88ehK|IXiNC@ypYQWuuU#PGSu zE(SiC#TOcKO+0cljipMl=uf9VTDGyp4Zo7?yI5p^Ffoyj^Y2pSbz!BbH17kfd0;l3 zjt|OBNfpaWE9Y+67vu+~dynN$cw?3)!wtX#(}Vv2*Qyal@)c!ppf}178%}u5b2M&? zmpGaBM&Tr3jt2mLpXXRp_;NW*G`nOhr+3TCaB+{v6}I;7{{VLaO`|^kzsof5xI}88 zvaZ%_cdCrq*iH%VarfRAG1~!W9Ei#b6S%WJdk;a=wPb0!70kf9TxLZe1a;0h&3ZtH zf{xAe0g;|6Sa!UhaS0tr=ia&_URJS$sVm&T)3nL$qJj6Z{n*@kXVi82)|8jATZf6I z$pB;$NayQU?_={L5+dP8@Zm0QLNSm6W~h%32PaR@pAqKfD|l z2RZ)$Jk(Kmf;0q3!;!}rDnT9p025qX`i!UmU~ss{T9zAW?&DL5H^^{=E7A{p=hGKX;as29AS>P|dQ2CF^Y;?y@ui;cQy*)m~14zDHqyYH;06$u* z9-TCIbE#6W;fT*UBLorY{(b31!&P$q?H!JuJE#?&MlLcj^A5EmUA*$fQb3$^U=Bh5 z0P9yjwp3p$WV?i0l!K5?c+dX;Ua3cMdQ@&hkWSVo9-oIjKDDG`-pm}5-5a{3vm}iI z#gzaO#0=J5#*Ho7$vfrb11T6Edy~iITDn`Qj}tgDFvbt(k7~PpWenhXHzp5|a;H5G zYSx5qax(ZWWyQq1g7Ql7(1DNFJkucXbaBZXqCn{Ke)2!=gZ}{5$LC#zmM*N67c2+L z4nFYjR_$zAWs+FgmnQ`X;1GJ#Q<`?ToFl!CLiQHXRykwKY;1GSKK}rfQj^Cr!lBG~ zOqKb4dj9~0bvL$hTwKiqqck`&3=a9}{(bA4xbS*QYVr@16SyV@KhN|PP*mT>M4Z>c zLwDksZ)4hXx@f*->$c_Y64b8pWQa#Bef)z;59{!zcs)I(f zOLf>-%-Af?oM$9|K0hkja-$V!yO9-APVBu7qq;VA55q18w?aQk)faKXj4`oyZY2BG zOfgLwM;x(6*~xOe4`1=Cm)37Jl)@z&y9R6%T#~i)H;ww1?e1+#D9SfZgQsy*Pj4H7 z$UaM_ArE5tvi5ey{SOeFmwL_X(6r$Mmh^bc$1~SBU_BCSM zqoHD|8+Sh9vy%7AI0?J9Pim3%NTR`D0UV4R=A~3je2kXr({hvpX$K&VhuX2OG!HSe zBC{zZZRx?SNVUi%k)vkAbI(pctyz22B;@n`YGpKvP`S#%q|a#PAks8w{NVPd3wDY_ zBV>pB>PKAnt=aC9M{g_+PhKlFM-KRJm=Tair=>1;AaF>6SRip82|KvK_BAcUO4nbx zbGQx{88{x*2iPW*vqv_;xb(pM>QElop>=25l^A@3^{lxH<`U~nR||3Ff)nN#MMg1O8bsKb`CdGiKyzfrKH-%Gtr311GZ14YRjVBOik2dbVrqw zx%|Hx-qP(6Rye}!0|N{Nbk3|IuWOk`5^U#Sb~dKw?SkWkME)b+@~oSaHRZTy<0GCI z9AiDbYqGo3)>URK=V>Eo120~xTRl7f04nG9k@%6PBiP|>{6BRpf4&T? z$L3ZUBk-he3(oR1ZyLJei3q_S)#>KOKbXSExj5is9+jVQ9Pq~(MOS6}z=6+RX?=2} zUC@1AJxnbh!&cUCCe7~XNMgJZ>DIb7v;P1`3k;5=azlW4^yBMQP5f3{m>d}!YN6*C zrarc;zFd1%obkpu(8jIN$jI&otg2wsRJY* zTFbZ8AXzY`Hj^3Io;m*jJu6jbNsbDI-ZG?g6r`Q*HDi|5;EWNFzanlAp1rC&Xzb^Q zbCTvTF|_h)Zu-_KZMHl@TxSco4F3R})higw1&TN};DMLmarCa3PxoeSKJlA2nQY6L zP^LeH&0@8qwZKp_++(5kuIgCb*^)@`dlEC6#J`+DFae7o?YB5IDvVNsFeA5VBq8D| zJMI30w4k?v(o1mCDP!`Saw)HF*9+%FM&NS6xW!Lyl1UQ>z`^RE9x7^H!ip`8Iuqq* zZ`xxUNdxZ#>O1<@nk;E+iIGskenyOpfKUGbT-IW=n-q=ASKpt)rCZX;v@m=O;l>z! zM|$RM*x6XsD-k*QdH(=xQCZ%7spPTGu>Sz-(OGjyy$slOhgn%(;#V2MDIWauTeg?N z-4xr(44VmJduOIUI70#9>~#82&AN0Y8tA_Bl6LBY{>7<ICfjYk-->M zA~gVZSt>=Ht<~&Xv1od2nQmv2D2c$Qb-sW;P(FjII6drgmK(Rs0Wr#an$`QBJ0kIbGQJ0 zT<6lZrG{4bjAvEfL(pUKU>33d^^Cxio!z~C&S}>A+v-z>X*ae$V$0xmc(X_tu zgq}-nDp+k9z~l0*ls8dnafq$nEweD+o=-u6>;C}Pt9V!~m@3kHot?v2J+mWW~o-h5F)s?0!lJ+s(<`ubNxqG`<5k={*hBdkq?8OHICPp{`*hi`6L zCf{ugP{wwI+yTh%$J4!M8jhQ^O&k=}+2neMfbH#U)>vmUG*JT~j2t-}o_?nT=~nzL z;d_glR%?`4?e~1LN^rwHy@&W$Yp7pbTivCkw$PYl`=BlW$5LCrVcVM57KZyqR8`oL z0_ryHBUuY)cYD~rPdmswe2-}iRoJ^rJw zy+di>TdTkldx7Refs1*2Q+YYZ(;v^;g$VA$o?QjfpHaJEBuXHFxcTx+1Dt+!W5i}P zvQ-x)wtdn;Q|*J&x)<>JS?MbZ%`YxacXBh(9DW1vtZV-O563y#Z7VXd50Fdkz$cJ@ z&myI*O1_5)B;RFSrM$`CIStQV-&)4ht`dG%I3#Bsc<){6d_BC>uBDmoOlZ%&8yp|= z_*VJ&d!-^u**4+Rg8h;r0L|W?xkV3=DVV8rO%zdQP8aVv-QiyOvkL5wZY41-U-`xUWZs-qoLS zK^SCW%5j`={P9eR$)djV7DK*Q-6Cf=$NA>4c$u?hLMZbaKZmnTs9TGL^6laO09X$o z_s`R%Xx(^b;>f+$opxl9zEKyb2LzLz{GZah`?+Q@%MnZ?Fz5Z8k@{4NJP`y5usWQL zzn3|wc!{^D{ft(}8Kc_kI?VG&E#%T9BlnwtQ<6_WdF|^{Xx3gYT}nqV{Hu}$$;LqR z#d-yt@x=o$EAtJ<0Dd{EkxudgNdr6q>rb6Ng5_&lobBA&uh~P#0Ni3bhd(O=)AFk} zw=-E;`Ine1z_1D3!_{hh9)AFvG*275CEf-FT-!}2#esQ?ua&l`;mgIFd8&tQGPKxhxlySUlT<;nE zE0Mdu)#tvJ=^_zYKnpe>JH0puslfEW&0M{aZe)l-aw1h=tc7uaGC2I|TT7ib#ul|W z+QTFPh328Q%1I*|L(sL`?NzTe30eq21gbXR!yuJDoMN^w>|wdoe%B)dGAR*5{38d0 z^&NjIvmc6Kq>I?gal|+d*mT|ed4DFGq}%n^?%2iQ?B!<>HecHmDV0~~!$O(nIgircUwhiKsS{cAGs#H$^v%@i_C zgSR7`bD!ux3ZV|QsA>rF#SFnW?O4xz^gowxP-=NPmCex5)-@pjD=bQ4Sj!JwC|m*f z*Dv9rpjyo)r8$-6Rc2U#7|t`t89X0fO4OfAzP+2vc~xNESdq>~J9`1Tpr6A)%lotQ zA^Azl?#4U%y;paaoph5 zdkdKelHzH6#Y2(E!?&l<`g>J!Tse&)tVs5a6jHRTTXA6d00E3wta_VMBtOKMopVR+w9R5 zXL9EsAmo9A{E4e0QfPL>Bb1>VcVh(L_dfps(zCT2yQt@l312KB4$8Yn9RNS)rDDx? zQ9sfrCPS9MZiDgqe!kV3jmvJwX?JpFWS?+dzJoZ&@)^ZYmU$J6TaPn)Y;MGR=jtn& z`+UD+is_eX$_puOa58wu`RP_u#1^e+0!bVaI{@2=#?U!9{Qm&Rsk6P1?v8*Np=Xk2 z3j!9yfA(4%qGOQ(N6eV|dQ*Hb6@ApL}yw?=Ow73gOAYJbpY@ zQ>x<2P*ykXRHU$(0v)PUx-Jhr06v{-WyCSMx@YC(iRT@1E6>}+sTmuk*k6(8KD8yE zi9<{yla-PAbI@ZX{y*bU%{S1i$78($F&U7kR%4#M2mb)9)oYI-$dv5>07xWf{PSGo zJ|QwN$pqlGbHe%xQL4cAB{zJh7~>(o8n1h>d#vbUxwn9-lmjOlhoS5JD#}R|Qi0_# z$@|A2=M_Puwq_;3VBi(cKab~De$cXFHcS-(00WLGISnFfiPS?OjW;k;)ARzk-CBF3 zfhLYNLxRi+;2-|K6|*JlTUs-?3KR^Uxngn0<|_jK08qHU{m52HNhFP@IQ+hpD7uQm zl(|k0`&PKTbxBqBvA|M&c*o{HO2zv%!GZ2A!3&+GfaC+%`&XhSgJW|OruCNL92Q() z6X-t@e@fW4(qe{83^XpFG8GtJbJOWvYP~uUvPU{A+~7xu)Z_&`aaNh4Gx=B%sq`7HYPh#Gp}jmh zj^`bFptag4Nj_9|#A>}pKhA!Yp{Mv~$%;6@E0tz*=)?}6O#YRnhHHm)awAf5*!AuG zD$-y70HGF@wy+o&0B5)1SvvEKELx`<+@O3jZ!9kws8#?C%z9vseaXdJv(PMUna0vP{#1~7k_LdhjsucDT;q{g`+9})(=KZ|C);8eeW!49 z^5>63RIjv0w+8CeWsnSf-oWGO!2GFZ*FMp^%8lK==sD_r>iXZzEYV0w0bCXbraKDh zjGId2T0IUqW!2VqVhhQ*0EB0*eKX$`*FzQR!m>#J05}DHQNoXJ@v5ls#1xbpV|+mU9V|7xv>_9(_VQX6KLML#_jt*6w_&Eo+L&&V@##44h&S@bN#Bs$7vo7tR zsK6wVkZ^stKbDmd-irpVqiobqAK=l15?X5`Iy;9`)U6`hBH=Sv-Kd zfGit1!S93h>IHXBf~K`OV^z)QY>TvwQa_pZHWXkS9G~&;RrM>0=Cvl-8aB#}xWUh_ z}?`I%BCdC4mv3y`c$^M&YFtEs93-R?l>4VhctSd>T*{)cCqC=_X;^DVJD#K zc>O8bNOhTSnF!q5aNyy`pd{xU*H`wtOY&Sg>`bv8h$I@$zq_{*vP=ks4WOvcUvFN0 zC{w?>ken9xG``T5!9H!uK~?GUspvlrm7KSzk=&|8t0&qFN*H5lWyc=F8Lnqhx{)F# z8=~x(!3U}T0QCw@KHBc%S8;WARa}==UV*qd>y9!-YN$6Gwo9t7WJ#(^bvC8;YeXZ+ zh%8%skf3DLj|J9~a=vt8NgrzYn@JhR_p&jXyC$P!pxoRvN6(R*a-+9AnvyRO#j8y+ z&u*(4FWn;~pHK7YR~~h;(1*(RdYQl4hGa=CBE*Ag3@;7nc^x?)m2_H7xm~hJpE5y~ z8$cQF(yi&5b+yD>K+$q8bPxWsNB0i>^8Q38vLcLdXQfe(Lscgyv35E;EkgW73v5*78PRW5#!oPCyw0@vN)OCsVYy-xN~$w=(Qd z$B=`m{7)Z+GQ&aD4Y_Gak74=q+pZS9WlEZly6kz*q}$aUb*+_@%v$8Yz&7;Tz!=Uy zkg0C8s|`xu4-&=*QoJ9W^*O=gzvsEs?0_Lu1@S6@=x>j6{V)>mk;H%qS;*vk(N+Y zXWOr@HKMvcsx0K+eH>CL45%Ul<>!OP9G>~9tszB`A8Smks93810EgjO%5AM#ae_wT zD=b)&SlofnLQmyb6HRvm$g@M6ch3qqI2fy+ZIN!shR-8zS;ym_c{{R6!s_pNCCbII>Btk$Zp#=B+Y4%uYL$=M_ z>?Gvv&mZUBw4O4evqZ-Y26Qa!Z9I}W?0Z#Nbo-l^2Q0@T7FJ9uzB+mmKPuBrj|h=M5{r(VJ62Km9)_)RElvfr8-|UH zZ;)XHqa&8V&Ocf-y)`~bB!HCKRzBOhka5?gcZ%^OyIUL(T;s9DMJ#ZuZTVBnC!qJh zu7z4oCN7e>hizuI)!m=)Np4rAtZ!wLLk$PjCe-HWo zl|uF_QDV@$@isvjC;ay{i(KndPlscIy40Cw+D7una;O}d#?>#UxBw~LfS{_Lynuh0 zuEG2wlgz3lkV3Kin|Lg8M?X*p<|qnrt(;Uj!u0$^{+tDW?Rtk;3Ax;1mv7^_|!|`MTzEk{!+we*m0k8-}SAn zA5DtQ)wh=0w1bRt3D4(Bud|!c7fnt(oX)WjRF>Fy$vyu7on38a(>_`d!~ybx4+FWcGMR6!ZZi4noHwBv;Cl*cYcffxnB+eq zApn8KcHj@xes$FxB&7M1F?fq;(d-sa9n^VOU57XYy7QdW@>s<2#^|e*;DUPp0G!t) zWvIgrk7}N0@7>t?cOAR-twq*h^NejWqmH=b9z8$LN{(40OQTL{65npjBaShj&{IS! zBzYNA%P7wt-`28k^%Z$zL~Kk*7#%(8i}<1_qh?c-Suq|vt~z~dCkaXDTAWtrS+#!8 z&)!@PeZT#6nfA!ymB^4O7~H3Tc;MD7-X}&AN`b&21kX{d;N!JoPp_jzy%?(F z9FQ{OuQWxhB+=&>BlwErxBmcG)hJ1;lH`!c{4;JRk>@DLM;vuOL+w(>rNs~;ISvCm zg#Pc-^r{y+%lS!yB~au7I*vjA04AGje=#N>ErOht+rUsq@}($CaEpne3&$?N#fAo4 zp52GNBV38x2?t+K$BLMv0UqSaG1|lo;i_h|TSDkCesiCfj@7|ZpHq0T_L8iVtb0N< zgBc^!ILEhN&Y`^1g9M0Yh75eOjE`|r>_xZ8KfR26t_Qwq!Y=0C31uo(y?UC`61Ku> z`<#Bb(^=2u+f2a5`-XY>dB;CdRqbvrB(whjSvh^c6T5(az;w^Gb~0MpOm~Qt_Km;+ z$sbB1u(k?a7s_zls2zIX*KBI8TUh6CcOcSQO{g8WGGi=xB-c$79$$gD_U%|#0c|Yg zcrXq_9(d#Ynti4Cyta`6!x4b2d*i3+Sh;FwmWJGykRb{{8@doV&!t8l(ZD38amY1= zi3A2`3?(d8dHcA>{{UXF^-W=|<`G2XD{|~VLHzinxuooY@}zbXc~iDwArE3kYP;?X zNscn03^3|@{VR+b{lSQNPUdABoToVS7_ECy93kfPKLwDNTgD^JTU`|{{Wm-T{WpL_t4IsR*E*3 zW>)9rk3T5w_?pZxNjfoo!J7=bh6mERR@0H>-72nepJCgN=lIraw$}?g%lB14^a&mbC*0%MH9j>4fDC7WgyySf=p1#oL zTWM|J0bg$Rz{cT>@m&$83AM~*=P2wq{t|O6YQc_40ddAX4Ns?P(%ic&a$&KCIp-Pg zS(Y9exSnjVG3-#o3UKOA82k_ET^5z$<7;zl&kC6Xm1Z5m93S)Ewv{?iRz`80ouac=_uL`58YTo2yGNCCM9K1fb612Y=SPnQl#{*oqIF;4%EgGV0Z3w3VI|Dsd|rjIh;d`N=>l~(yw`UhQhgi&M2@-4s52bV3-k~ZPH0H9a@>6X_51ZhXf*Er;Qf+-2KvXn}(E6KB~FC)|RtBH1AMNDl6h9jJ3 zHH}J+dL&$7%eg{ZJB7Mt$uZ>MH`g_K-DO*2n3s41paUoT{{SkPu2ak?%2r2 ztm~U^KHqlBjXl~x!W^Hv^Yh8{w`INaIC{{UL8CYyCM=X6{H z#yQCTMwup^bi;sBG#SV}k6NiT$w{IX)UIu?(nB1uk@GU+KjZnD}q-Y5BbGpOAOKZk+D1+>?wx&iX%!7)R|62qj=fnN9RRlePEwG{%R{v zVG}-fcU~UT^(kzmot2%DuuvRrJ%Fh0bbH-gTw6;L+qy@;&F)8G{PSJqz1))9e`Z-) zPj4JUXmY&g9mi_cw9{@ZEs6U?lRJImDCjZmU1>gRqF&mbGYze_o2D(5)U3~v=Xx;b z`=C}9q&%P+AbhqNI5|Gm?V5&%CG<>WwT1Hgi^{k>bpEx^-1sMbxk!{k?nx}bU=Df@ zUY+Sl-dAC5G(3jlHhXa+jiuA&$j5%a=iaD^CXO&OkfS;5MSG-P1F}sv7;a>V$^u>R zGJ5AVR`0<2PNAvCB1aR#k*fJw;Cr8Q$K_hWagL1{I7#ey_*vw(Sy-RmHwdSmdRKRC z;3=gMt0|ICEHPy{P~M-GD&D2=^(^%8Z1=svkU3>+YynO>_N~1KPS$O7rDnYV;2fSx zj>GY%Qd(XtsK(o)A`b*kms9SYCkjR*i~?(7-$7XCPqh%O=n38J(}CK%TVdo_34v8F z_xB!2$6lRlBT&_>o)X{$Wa`Q{IOhjw_O4oyl-8#3l8(nGtIcg`wm9cq-(A`uxsML9v5b-3y@##{{OhEO-@|trtQS%@nE5TbKzAOPJn@h5_pYWZEg|EJ z$W)DCl*llla@geY`qWdyMlRthvStN@dX4s+(@LN(mSo0z1JL>!VYJk4@8O2sQV8%j z%0c_1@atVnck)FciYs8T1Dt)_^U40djYB=FrwbqIsE+z7&`@ z+9kOSBQ{C^c9H2=8n1$GZf+zgDL`36}7W@5p#{=K0wDk zdUyPdb8ug3dTeHWZ&QVAgJJ-@$uAhjI|0+ZQjMRwE8Tm>eTT!FX1|{Cq%tIO0UG1v z%HxIy@TG5uw%%|qM4+e-w>z1E`M#YG=Uq;bt6l0ExQ5o+6|qJI+Z>iWa@p(nRmqLb zoz%}epDCTT0D1eFBz;bQ$)@Km?j;!ZF>QPgriTGUk;L+Orz~>Zbo_eN$M8OnvMuqp zH*Oy{r3B7uvu*o>!5A)iy zwK+etEiK~{2lEscVIVomM9HLZ#%C5hS#bjT;^>q%O}XF+FwCDbn*Fk{PLrC8vf^NNlmbq28#T@`Ca1%}c0 zSa3IU+#cSQS5CT1D^^%d#nP$VqyTpVo}I8TY1dOM_TFu>?qQcD+ZZ^i<`uOxHMo|2 zDtRrG3xK!vE0I#pY!cgX>aZ8!k^D$H8k zE|Kq2s_lTS!Tf&;WzEEKo-%)gXQ=-GBB}D*aVy--y8BwXc}s-ILGRQ2O>=j)dW71l z+&qdb(BTn|8L`Pc{+~+gg3oZCQo4prfsxSmu6|Dq++6B1H1kUFlpixUR>m8rK8F53ZZaKBRltTj8-XxuzSj^Vg;03YjvSFL;`uv(JyIcH3ho`;Tq zJn>u8T}N(8$U!yF&*MvHxE5)HyCt%5fGMb?4YpmmSgjO9s_d`F9S3rMl|VHE4cH5Y zJ4*wegWj^P^(nO&ku9ZeWY~{`fIz`No+_obje5F@y>u{FBd+XnkM+Cjkw{PgMhRe5BW${`~p zw1a3Zf_i_P{c04QuI`mWGOm7h?Z;2cBm9cfl4#6G7aPu1j(SpWQP}0K?%Ku5zymyl z0hKu2jOY6P6%;Eh&F4)Q$fIgF{`a{21#W5x;tk>rz=4Gs-_LKYQq%>^Q(D?AW66pj zIOi{(xE|F>lF>xm#;{8doT%lCxyDOz$Lakkklx!`MK0-=auS9|Zg2qOgO5tDccp4~ zHtGPRqU@M zLc2@<0IHRS{(bv$D703sj`DpC5way%(LZ;BWH=ya033SrQ`lTvLS(jur1O9-Nj*+8 zfu7t7hSKV3?pEG1izf09m^fk1c>F(F)p#vJE6F5FD#$#tr>;NG>sa%qUoD1ccPlen zfg7R{4s*`a!3XlIQpXf79i2j_B!k@Z{RLxP>zZzw)5C1WN#kBodMBa(06x{rN8-DU zLr{(@g!19Z$p=3-ujN(j>Pqb`1VHG|*DBh~ZE?0Z z5j&>?Cz4>TTB_t z5w|Yc10$|#D@)l%@+t{U=xsr#EycW%&2oi{9I|Dz_j$?aLG-6u_*%<*C~SooGBa{J z=lP$?veU%2wtsc;xaV#%bC2mve;Qlcsf4x>hVzmRSo+oxsW~roJxv;d-J3IM)(}Az zq(Hvmjn1Ut0CV&|<6Qo$;Ru#Ujk1s>Vyt@X0CoO#KA+-tl4)Hn+}pyZcF;1}{{ScQ zsawSbpbO2lqA`#F;QfD3&(^bb zn|hX@lF;)#drf4yTVN7zEwUOj!w&rZVzzY84?Uq-Tq7n2-fWO@&OLhd>0L$Up9@?o z`Myh{ZY_?(pU*g~%RBLNWd23Y6>z1VL7W_t26^s(K9$m{IYP+C*{I6pOVVJ#B*een zQInr@SQnS_#ExZLpyYbjL3w+o&*j4$GRVYo;OCCVoaeo9+KHZTEmA^}i~tw{3GSmA ztd$2ghdP#87}|~8it8rgaC6Vo{{XL7bp2q+i5^*2Hr`5(N$>oHTeZ?AzMXC5gdk1C z5I7@@=C!Z9Ck>nt%^NB{;J#i?PB;<~R*S`TxbMt>3`iso5w4ACPX2wjI`>HPZE zfEP0#E9QT2Wh>L@PwDvAJgO-> zMCnjzU7V!eAi0Hwv%Y+$!RLT;f&8nevDDSDU>4NPOYn-vW5ihljY8NALkX$*y=ae-?>wmLFIA|(Vo852Z^RK$qlS8^C!qg zd-ccZU6I0GNl4CB{npUULsw&LtQ+`&$v(&YYNfs8+J(|VZtAPdg^yu@ny>a@abY#S zM(cb@xto#?1b-^Gp~9L-yOL!a{Iaq6gK!&x7{{+U{41_BAqcxIPG>nvTI^48e)jUT za5StD!iHn_m$5$o0OMT_i>%1a<;}vTan#l%)-&oB##lxq-l$cRZy;kh>5e}Niqlg| zG4@GeVulyjW*_3d0`#E zC@scu+PVof^qN++NEwuX2?v63IsB>(GfcL+xt8UvWsWq9a|S|lQcP}Aq?E@JHKQQ_ZwbaAm_;p8$V;7er zIb?iia06){qMy#M>H0;DpW0w#&zbUu?bieJHLUBxE8SLP!i<~MoPI^5yVQ>?kPb!( z;1VmN7t$%Wi9wN6WHSJ8F_X{q@0!%L(k<`p-Pp*3ZcbMVobov9$8V){x^IUq1(_=t zWoF&;bp!#({Ey~q3091>wx-dgBzdl_tUFqkj2P9I3aUFCew4*awzx%7$bA8U9+Y(;m%vFH>5*nVG?S8XN>7kiNV{N2FE?tT9NFV3^PEo6%1mGvm- ziG4NfNjn6FRLn=XY%d0r&QFCaHj(tkn)ENbmkOKnzoSgIr&|;ZquE(UtE?Y}t(y=?3V>#>3 zaf-91$dG9>NiN0>%A~v~sm{1{iA5Mk--MV4yp?73&su(c=g3$E?Dkrxt_%d zd|!8Y0>^D{BueYcg~z|;T3UU~pJ(#!UoPaU0^p2s*mS6Dydco0@yNp)knp%Zo$*$6 z4Gpa$^KG{?VcqnmBS*b86Tm?=lNHj-3cR_a~NR+a$$kw?&wF* zn%~oWv!sd36qMuTKgK&})Bgak??kC6tAuJc>~uEzubUWQxD~^)vYecP2iK)C^H@V5 zS7r#LWaGX%W~*Bk2$Hb!%bXH%^#}Deu{FA2Kp{p7bB&;eINhJtvTY+xNbQszKP=2c z;FF%8;3?MH57?ETr$IPi80V*0&q@GYLfo|N1IU82K&93KQ6`X zj->jG)mb9Dw7QTfnb1B&YP>#rjGmlVWF(s0!b#kE+1UlL8pq{?d7>&DE|NmEOXNXkEipg9{nPcDOeDV%tQ`bjQ;?U zN>XA;BU%UYjIc-!c8p|lPI^>v$rZJu$+Hp_W-FYW@<;jhtnF`9TU#HrU_6eh5UA>L z#c^09{-+@ZC(x8AeCV^9+&x98}KtX^u9v$4hdH z3PB3_aiRO$Z~@8uDodNiwpEd3#3XK0o(DXAJ5+O6*~tSSe8}G^8@b8PKdx&ZP?pzA zSS+rjk>WtS7Qp+%C-lc^Q1`Y8I~vkn$2@BiNFe#n*(6>LIUwh!*QGpaP}o`-E_Ox~ zY-6|*r22aG&2zBp`aY*CAZx5aDx83Goc{nW)uUl=1>!`{DUp+aNy*BL5&nHeX|{={ z$WVZiMyCo#e#K92#`wY~@ zk_(XwC}m(21A~HiAbwS96@(BKLj>S)&s@@dnFOskz+&5vUT|_MIg7B{n4(2gVjCod zCzI+wEK@Bl+6#70Hg4x9gY87It;?x$+mXQ;=y6xbRgN_wKwh4t)@`OY);Vi@y};TZ$*AI`OI7#LbO*-3MfGHX8J9o1plf;kRc9R8T9 zhJ?>kGT!F&EWTk$CR~`n7&2qA_wPx26!KoHuG0wU2E#RA!NCE2!g%OGpBv0K|-O=}RTzDVPEd8v_S8Jq2dm z+AaO8kufOoI9C9jzP%4)QbVUGu`n!(o6lVH*Y)6jwTf1L^E7X&135e% z{eLQoRh(0bWloxUoZQ+g+{*z-Vnl>)h!5azL+#({2fb3%yf1Y3KtRj2otV1z9DDvh zg>}#%w@syZJxLrMGyLicolzrYw?UaD1Pl*P{Cf}2w9f~nrOz^urN|(hmR+S!^sb^Q(tBv$ zH9lA;KkSjze=3V}MLMtrw|v;{M>OS9YfFhjERIbQ18so{85SU*1J|#A^VYeIN5gaZ zf=gBm#O+|?0G@g0-yfZJLiQwpK61oxdyoFV6#oD^-dKwgynNX`eJeQCcP-OaJlT9L zt4|cJlDbbA+R;A)Am@(68XHK|ZPfX^DIh2eerzctr{i9dk}QZ2l7-ivc@;EKMB3l@`NgQRKjFTxQBCf0R#tw6z;uT`oOWAR{W4uT6AtwYMap_$b*x`ml zEMtTObKBaoZgFx!vY3Cm-GV{s;3k>C@%hiA%A5*6HSq zTu6m}ZN)Rtae@5nR@PHJtIQK5Fkyr3kLy(h02C(FkE|j)q+Wgq;HZ3 zZ%qFHg&F}Yink*J0U1a*_pWa5!)tKS$jzCf1P#L>j(GmHp&i@2(cmdkK?EM4_57;s z?ZkGmq=m8kAmgnLPA@^IrnNJMg=1x8=#ZfEP6)?-Yc5F6oah--VIYR}HLa=5=Grhr znHOon?afh}{V1kLY^Dh9?tcnVySrq&EfFH#K_qOdL~;N|J^ujCD?WWd*$4U5N4OD_ z>;C}P{${atJ9#ZO#*<*F+6x||@T^73{JezoUTHkUBX5=*#9pgCUUP6kJ>82szMiqGt}Na&{x z7zYFEMk1VHuu_|r5iEd)h4UuG_etb69vY7M+f}+QBT_E;byu z(a1zw2i^7QRc5lacU|#DSd1Kwzm_V%iX=wDVD|PDOA~F#5w_989&0^Odz0IXdvKsf zl`D*cxK)??I3}vdeiQ1E;6qMd0-0qRJk$P8dG_4Y$OjX z9t(HJYGks*12S$67~tccxy@(&tImO#=Xy3Bc>od9{3{nwySXS^1~tza=kfkkHf@gS zBXP}}v6QjS-J>hVARp^f$0T26P~}6Df!h_!{ip2q8In@U2;?{3#yWrXsRR*uhO(sq}GJ<#`>MTuttotVTe6VQq=TVuYm-p&r$&7WPZE~z=K>d`HUGr zVU4-TKT4ht5J?b?hU2*9bI0pMVKnZ6xV5Q%5;92{}TBeiH+>hVaya;5r{n$^j*X&LgQ?u=7z;ZW^37!C;Jdx|Z5 zxfE|uh_Yku^O5OVce6z#n_rE?gIN;I6|z5+LCN`)=aXF8n->k9=|U;WsNq|#KEAZA zZ?zf$xiCRePI5gfIdvF;4;<~*lxM;h?m*FCFROPJl6mu?0L!0S#ku$s9=bcBy{wT|wpbJTm*wegXo3lL;x$T>jAQkxQf=PiaY6H0K2w~seuPnC_IBBEXZ`Fx7KZp74S5@sN0w|Ot zFQ~=|u7@VojJZ|E2^It!xm@Hh86Sx4Rh8k87}o*YJ^GL9TM%jRx`3oH0~yaIsoZGs zrs*Tx2_pzd$TiK&XQ{2-ig4-n?-Jog^f_L7Q(o5ESlJzYh!vp?rgpI)vFpwcUrL|K ziX!Ll0(r^lQzxlOXmi6!UXcAZ+mu@woFJsS0(2r1_;428qDPH*CS3Tn!%hP1AX>KLGd`46Og!ij*M$#*N znq(}wStKBG++YFvVzac}BJX*dP`XDs!vzF!*k}ClQO&NUa`rjBJHoo-#$>$I+TV@N z%Qk%v3On`ZJ*#$GNpu(*=g6Aikf+wf8sg?i#j+o~;r>G?qvS!>>6}(6bTOucvD1tgPuS5ABJj${{Y$N zn4<1>3PyWi@kG0V>~Pkpr(0e;@*}dw=VET%wRq1%lg)Kja?NpclPoBf%n!&&BytaL z{=HSvJT+>d}#w&*rfsB$15!e_GvW?edaDPR*bNUW2dr)Jfc=tVun}OjandxD2xq z_|_!4p|_S%8VMOm&PH~x_2c^bR=yTow1J}E@@)sUc^{X0=QRtJw76)j?a#{l6_rbL z#{=`{t}#vBhL$Z2SX?|{*|c#qV2_XhI`ZA|ilIM*ZFLKXF7ECN?8BJ$9zf^;KZmy! zgEhB^+f@?@GOna4=mrLGania?5=~O*2yYQ%{pJAf6n{_i?^N#{Qxdb>uVC74g?7to zK;ME(Ch0TCCq0Kx#;fZ3&DHhl8*DOTB(j`ff;wmX;<^X4i_VfSEE5{8UQ7?f`&GDX zE#k_1s2g-`&;9fm(I#&lvu+_}fp83y2G5-Xz#%G7Bl+9=RK-5(W8$`cuTWg zO51}l$CfeBAE#=UO7PXat;qhc=gXr=ZseDnxw3g zJ<=do{{U8p(;SoO-}J1zT|&xBl?dZ@a6ayL>O1rwWhIPLJ;SrfjJV0*6O+f` z$K_K=d=~7)#D|fTAW^^vKhbNCzt{F(tQvF$RTSkmf(Ziy>(Z}T>UXjPxx2TF6&q0Z zZn>u7($q<#xHl17oCZ-KB#?T6S@)AkCCqUPg^ZAM$4~SA70X2~u|BHSyVSW z6b?!4)~37@Tk5by6G(i`?(fxx0RI3QPp~J{+0<{LisDGHSpotEc_Y3(O)?!)&IDLf zA(70O1Me~Q^*q)_qh~fwWh_)F%dg(#bI0TPQrkpfNsP#fiU108@}B(m=lM`QN8f93 z&8z*Ec}fxh%AWboKQ8|D0@%kcqZ^_GWjHPdGC2f)I=O44*kNuRcQ)dD%>2iu2hd`o zy49`i$SJjQPTXVV=7#$MUCpaoA1-4MaAS<+02~lT2lCBcvWIoycVn~-!=5;}q8c*70B?OZg(E6y)KaW4BttA)OcSlVmfoC!owZ$_+TnG)x0Z`>}z5aaniQz)X@OF3@s-4E3x@HTmx11hbO3Cj*W^ z=lRzos%n=jsVXDNSTIBg4;{&(G@RJoMHF?HJ|~Jf*_Q%5U={8Daas4CHH{N&0Jcxc zPZ{gi-nn41%^M4sjwW;-QW5j#sn4c;Pqk+1aICv9X3jQ|pS*cF{{TLfy*xB;sg&!= z+8%|c_{p!^=1q$Z2_^B82poTfYuIY$X&P5CmfMsBjF3pj^{*+O+sUta>Uz!Bh-~04mr|@`g04?EJt+R$(x9~> z3H;*$;Q%|aj(^8B=k{83w-*QPSC1@_;flEKah#7z>a8?;d$j@Z7#zuwjxYv2ar#zH zFZ;ypUYPm0_ybur*DJQKh?{vEyh)>D+z z<&LJ%QEKuTW2em?o}O*siJ6H7R1mAT8UFy#kJJxLR5zYRQ4%=O6saYUZbTlZ*YfLJ z;&{L16B3{)+K52_CNh>o3n|C3C_SzL_lXEWM%<8gJ^x}izscs$MnLm8;;7CV627g-X z=bf~;VYkzY=c6(&d>!AeKPq*+^I6Ezv!vG`e5?jY+<*OJ@T~o`_eJ|S?8t0%tv^b! zx{0M{X<1_+vFte?)}m-FZslZ!i)?M+)xCVPzX+d`W<~=Q%w6I?~JM z=@5xl*iO>pE1aAGmp`ZED=W9^Xp%!>v1f&&+?kOHB~P|FABiOK4ZbnP!v7pTMR<|7jfZ_4f&&Uve?b8jS)2^mKNjPeFMWBl`6{{Rc+HMP~u%}V)T zjmxHd#S9djk&fJUJXUU)&^^1`c?;#cd7pR>n?L<=(zkUh>o|hMI93=ThA=zREYi`f zqe$b#$lMGJG0E%Cp`psk!E3U)qT)RgU1OgE%7qeu2NwTXJX(HS~`QAdDy| z1Y-(%k_RAn?cS|gi+GvikM}{FVHwX}!}Y2+`lZY^=gHh6ZW+1(h9mR9{b@#Wlh8S0 zkz!*7yi)lPMx=onh```-J-@sCYnzE~CDg+bT_TOX@EjevQU`u{{3`57iKZEpw2~fG z2*}%kjQ1oC-Sb+OdR*&s=C~$DQRZar91sr!u;cUgts{81a$clbDY?{Sc9J!FLtf21ob-SC&Ec zF|!RcU~gbJ&$!R&SxR!|v{j2qTT`6WA+@x5C5>`Z=3qcOjyeI`rBt-k=ee{KNu|dc z$&gu-AoKm-sQoLTmc`rWDp`rh&vwrMeie4&%>-(!yQ2d;N3MUBUp>tZ&}oMCNb(oTVYqO6eg?PVh7UP}YqYs{Cb{eH55q0fv!|INF5rxErwRw=Ni2YUQGmHINd6r~^Im-=O?!IvdeD6EtY0Ni5q*KhC|vdpirO zArb_2M0Hm!^8mpA0H12&^?wK2{egbSS;U0NDPHHdLHbov#Ku}l1xgZ*%;)VJN|G4T zS(r;B0CKp<>!0)KT2e=2BSflO%#e<8l>@d1;p^U#+rU?nUHJ`?g`6=9!UCj%Gw;P~ z-grF6eQMFl2bO|140>aX@$@FDa;JU87|z=dfue%JZT`>{u?i$*0he|GBzEuqHBtsbfU8MpwwFTM3qLVgkT5`a zUD@RNWM}^X*IJPxqofd#8nD=*+n@jek6&NHqmL+7f0RhLUb!F+^^~eM%_B`DYq7Vs zwldEgQSwIM1_vklAJ(%(Hu|YYwc28hcZWbZAc8)-(*YK+ZGAzt*u~yn|0EJJ0*jpkN)rK*vv0jz2nu88@L$NgYH}iOah= z3lKR6pyR0gKb>Ogs}z%oP^R_)2HsM3_RGpkW83sCreT|)3pEG{RLm2g1`jPA~P!Rw0Dzwlen z6tIU@c-S-pxxwmwypPJHwZE{7ONfhjp_F3>xtFYXI7=K5`Q<{X+;hq2=KS(M0a;LZS$vhcc}puFDK-UcAH%4{ zcM@LP&ond5Fc?2D{)B!M=hXE0tk}j>0EcPE3VM_Nf2~TbG^|sl2JUgNXkTb5U|C%q zztxNtPjk?B>z?Mi_#m>i+qL|+W%;l}0mnZ|z#nUA?n0VI3%J@eD2u&lVW zd;1MSN4a0!1}wk=M;PFaq<{76t~A#pN%S#ueAltm-B{Vr6I&op-V-Anb?8oiDyyZm z)}mWs`_y6x8$kygaC+2B9I;sl*pl);ml;wx$T{cn{VPXLgj*P`o%bfuh7Ha_^Y!E( z@@s`wc5BSvms0xKnDqIG;1jq4cWw0p+Lj4h3lLHm4aD@VXxMz*Pc6`~^_nVCvt{u%nz7Oo|Qfy$6_NjL{QV18BS zH(Ikvb{66B9DAfB9G1%btNgzVeJa!*E`}%~Np4I;blZYS=OFrZ9M?>+ld@>RVk3P{ z>1MV>`Q`oEuq?wPb~+EIudQHedfbgPk;N0np#JO1Zb=8xt2$HTrSB5?V#jm->;{B)zej4H;Xc+?<+H*)wCF|Z4=3sPBFKhyFkac zLHz0y;b{c1TZbze;n{~=k~7oOZ|hw=7N=rlZ1P-5@{`EVPuCxfO_3B&f%5^*BCg;u+?ww4Fe;|S~k0p#GWPDkTf#}K5_WI8QsjsoK9{LJ@O z(;d6jQ*rEg82{H&*v@-$W;FgBb<#GEe>U&OPg?mqK&p29iCfOpX(|2j%CC z<0hn0ad$j$D1t4l8J&0xLg0c%GI7Oq#-viw9MXfnrYD8%*ckrLXizeSF2m*I0!P<_ zUX2WXU8sHeW&s(neFvwosxU+&m|9!G5rilNs33ws&(LHVLv-dhh^Owul>~I>>&Wx zhFtx6k9vd34RmLR=Gwvbu_O?9Ki0F9xmPJ^UEJucE_~OUXkf^BVsaSNk5 z=r>r27bNBIPhOpWrDa}g5iBUtFm29N@~5x2G4&>_Pu7-2j(c=zBP26rho&%3;n(w~t%5F@ zj0G?I$uay#InURy{3~d*X45M+pow-1+meBYDA@jg%igWaeG0kq^1-=0a1CbMAzObc zMJ5$e3$G-5d)8EU4{tJ~INnsLZ1m4e{-2dpw$M@B>AqR5ot5xhk%7U-PwSCV+Cd8^ zlEI&592Yq`$-(@r{o@te0Nc_YxJdA>`(-%6IqRR&w{Xkg5P2V&{#AEH*Cm?b5kBUcPnm-r6rAt} z;hfWrDf06&T}a-?X=)iGnih})kCl&l#=SGeaJX!ON{ytP52b0?-9;wZOLD=1$mrOo zOKfG4WIXLTC)8*E0Ix$=LrmvpX=J&L3ls=Sa!A1$ApRpK@TzyR-$xi&#_}X4LcE0o z{{XH@uD*Lk0VTk|Tu8ll4%qza2hm|>W(|)sh8X+V2O0iUl1bbfZ54EsT&!<7lMBIc zP5|rI{PA0nui1*H8%gLsxvY&lLN=Gu7~Rh2W3~C*r_lE4SLC+2Qmh@BljS)B?&BZK z(CprTu7|zT79fVh9CYo?S2oIER0Yg`F>G}!{&7;ZyF&vx1h#T9-{115$08Nl#PsWq z-{V-t-RfJ|=I>&AM3l-2hj;^>pk$B@au*i5gjeN(-2`Oil;jo0L9bCZFFTl-Du9TD8kuEUpVItL7=d#!perbeb)k zX>h)HQlw-M{NvN#{{XL7rts@pPFYy_M3xZaNZA>QV}p=0$l{VQ9lJ|#A1qK4>DSZg#bG9|Iu?z|~k6-2ds^>;fT9X=zTN+7s1IXx$^T*VB5`V_2-pM4E z@-Qna#&^bua(%wN>KQGrP9=ii##x2|INgEQ>B*&SPTS1#UDa;mBzk8Yk=#(B)dQD9 zAIsJmS*J`s%$^UU=ls2^ zpcYX^h_ZxYxEaPtBA&Wks(EH03ugn{ALpeGqG%KuSL}BBh4Z+KA&oYVm!EEZF&m z?rQUCvCd`l7tnFsbN)4^vi$fR81c{bsNZ5CF|pg)qH@yZMm-8K=nz81&@vMHjt^Rq z?U{Ckeuwe@06l9!GW@5eI8S{OK=Br0{B*}pm8A$|VjC)osx2dABqt%NH=Yo02AB8+yd6Ri~4fA9i zcJ%#fC|$O3jr|)OWL2fOUnn}L5(9%ulDu{BLSVzpqT?L6Z-BaShj z^VYgkau^Nd{M;I&a~fPa#Oey|&Is$8tJ&yHv^bmHFU!+bJdqe+6h28&fIq^ym^Arg zkMZ;t-YK#R{IIVuK~#CkyT>R1WL-=T|wnsd-krXb(~{ko^Xnn$PKLq1G$6peCr{WJbGy&b%gLMDnbjsVK~@zWoLbm`>6#Y*9T@9R=|&;yJP zPDdE1l}9bgP_fKS1@HPHMceX#;2iepSQj(SZW<{=e8dt5)A`q;pDIT{Lh>>WdLD3V zF84`>Neal3`J5g5dE$uKAxT{G`>T1BNauKUZO7#}ARJ^Ltv<|W_j1X%ao~_h2kZ3r zuAflT90@{{b|(Rx;1TG58p@8!7!+l`BBzpMX&Nwo@4s_YzR?RXBytWgPx<1sgRv4u(BTOKX~zVNesxmq zr6@=NvCjiF3f?Brts=7?Ggar*qJ>6FFB$3vK9zF!wiI+K9a$~OGZV8sXOI5?T~?D< z7ZSQ6;{)$w`Br`Gu+J;V!*ZTf0nq#UR&uEGca!p-R}6A7LZ-ThGc^p(SdlmYo&^=2 zZOJ5yk^$%gwg>4&KW7nhGt#b%hB(k($THcHf#bi+?NsdTOu^lzVx{qratZ7+k8xO9 zHo1G^OW4#ze$5fy+f?!W&`xa>La(zD>zZ%l1@ctl&a{Hi!4pVF<`Ymwev&u0gh zJdel^fs>AdKD<_UY2L-y&(f!V5^1tUbs7kxkxBCjP|7-=!yP^ArLohryK=I}Z3~%! z*|jhfaB-UCwYwcvjh+FI%w|akoa&V19@(l{{TLfQj$vO zN-WXUHMG;6AdWma849%~lw{OV<+^u`oc{o-+74Ii{{YsmGg!2}(~?`c<}h3aV~|cy8TRZcJ+2-{L8)HCBWR$WG-%j@I(c~L2emzs7oc~?5}`)xTEB6Vb}8FttZROLu&RtCsIQtnw2Za?d!Uzpxkrym>oM3PWAK~7*UkZ43<43&`O)|-A9A-dHerYmB z2tM8Gthdsw?c`%14g1ayw-`SBpVFN=B$pAygsF1OGI$*`L#ZaYMaYx6nR(`FF^7^7 z5H1x-BsO{7-=`S-X*6qVi+hriNUxEVP%x^#-MeC)F6FqABO7c70fGCcJfCw{BAIOM zJlPKE8a!?4Jq8VDxqA^^NqnJW01fO{c+-mMi6s z3C2%c{{SkIIpAp^X-~-6E3}+()A`g`q*QGVON*%Hp6L0Tg2}P431D;i3{w-sBu8@5 zTq2hY%1Y;xoM)d?&*NKdExz2yTRGeq9DDTt06nU*NxXy%z+;U601tobS9=p{oMbv3 z^Z`USO%}qOT2L>7w_K%pPK z3b-4H0ClS{n^cz)5Lgqnk3o*rUgB#;oJqJl46g(4XB_^YtuA5mkB?8&)n>kUu*|E4 z?gu0FENcC`Ze7v9(g_)G-`xisAEs+H^-Ft*qKIR2w;XUsVt<`pit$lGtL2yytJeT` zG-}6d5}W4_3j_xX_nXt2hAl=i&np75{n8Iyb?;d*-Wk=V^9wG_kQ9#m0iRJ-k^o^r zp1$_h3-*%wKqK<-;G7aM+tB?fsIfaFYHGTJsKO{p3>!lLNCP}^`kJf1O-G(LxMFwU?gO5{j<`9dT1%;3LnM~*%POeGbF%}U zbKkvUELRq?u#zyOu~5>2!9nloz#rDNj4z=MRyAA1a9R0@X$wkD*raCz3_6p~Y=Kp- zHH}ABfn#KdG8}B|g9Dn*OIg0v3&P7QsNJza3d225wkt-~;?~B}XO`w4v_`-pk(E7( zKTbdT^-@uax>sUN%W}p1TG!d2EicczPKPu z)eCKEdGAu)W`a?T*d*n-90B^ocNfBMy4*4iO^KIb2G3Qv3U#(_2&7lY0R9dXA_c&h&Z zYL*?cq$#wy7*H~DI`#V3MLoQ0EY}l4kMen7;~R%L82pdrRcxWOpX~u`O6_gKf=M8B z!2bXbTG3QiA;(fHolZ!um6B2xLPLV5C%NZ6IW@VVyeyJQJ?WA{gf312>zsXZKPsa% zBIb2Ph(@U&&ctvD9S74VKIW{Yvk>he?M~miqEl zkd4v+XGt0=RTZt=qpE1@bbZKvs&BCGYA;(&mWyh z4S=-MZY4IceWCvVcooP622Mcfo(6q+&0jLM;Ib# z(Rt6dJhvIaC-AHl>Q3$GYTqPmk=9A5$EiW~b!B-aVX;~MR0I4#{Y_VoN>`7}iDWWO zBF7%WPShX$e1G3H&D-c2#1g2Ie8i20c+PNJj^4n1E48(`lTSf!Y*D5}!e{d>kIYh) zp`=~MAA4CN6H~Lkj#k971-Fc05Q0f0@t@YSG@&(wZ$0C$n(_rf{^=m~;}z&(p5pE` zaT@t(91=LrGEdf{zS5HBMuiHfC_?S)(~qFynyT%}!PD00p31Y;zrg8260N1IlG?ulGX89Zm zKJzwyT<0H|Kaiy&c&7!y7<9w$rl5x*D{&=clDBuFzd2q(6HiP%Rl$X194^tlM#(hH3W11k- zMe}7);|I4Ml@h}(p>Hs^&5*2A_o|wV_R>Hig##;K zsE~38ewqBmM3QKz=wv+(w#2tN0As7 z-zeHg$X5%DK3^9!pk%t;VD4`1?YpMnT&1Qy~?CnUJbAKrkV9)5?v^R3un z%+D*xLbn7Q9Ou{Z{#9z%xSqr^X?EeDMNzb2O8R4`;nJN2wY+xMGcXOeB$3W}sAZjm z`@#PJR={#kkb+1glhf<((ym_0_cA1n5NTOJwzXfp7aV;%=DEF7 z%7bXSLp;I0eTNFC(3+6eXuLW=XuPgQ?l9sI8ZQ1^v`qG@~-2bcuJ8gXABQi4_9G(aV)2HA?Ye#E$eR9(M zos~hvK(`Il1NwT`L6N4}gppUwkf0zAoOi`@{3_cdTB^DwV?SrE<`$8v-npL6a(>fpx%o-`=5y+JKh~nPTl>`NnBf5sd)z{fs@I`dvpBhJf%WRdsUcjI}UjR)9FK=uR*AUmsfGmDnPz`D!orp z@A=mqsaf5&xi6Es$lEa5zk48LdUgFPvP))yb1vn5!wkDf4V-5xJx~7tuA4ClV89G2p-@T3`S1Bv z7|r9{iNg+fa8Dp(?|v123t>1{AT)c9a@~E$=4unUqp~^CVLikXI;)7n7{?jhzPR+k zHC1#dX1r4oMz%=L%3D7+SdxD;{zY~-*6HO0TqtpXSB<#?81&~gLMDF?wmAdarChVNUnoe--*Y3d2iN@i)u~HjT3ei8@U5&i3kaPc70}6b>bj;NW0n0qAMA8ajf;IWQ4imJq_Pyl{Wlb)HR=Ik{Ub0An=T}ET_qly+(MQx*vxyEzb z>rabIp4tfA13Ze~JGdPG0JVX~tvgcHe#ADB@(>9jhCRQnQnT@;yfXy5;yDzPfI1F+ zdFX2;DNXXC-z;@zmZ5Og)5gx8RB6j$h7ZbeFnR08;Z-8k74B0Jx+JFz<2>a50Eqr{ zms+KUscM%oOpX-b{Mp=39W&CjbeFYmFqwuqTm@os9~Wz98qm#oKsQ2qk>N ztH&p&YNK-;vtJ?d$c=%LM`6I*&~yHHreFA;-o{mmBC<_@imU2#f`1yRHoq0ZOnFBe zqAa}%fC<3$=k+y8n_CAmD_>kBQ{*r^SUUXK=cnX9tvc%FU)|fHD3Fci{{V$lFwf!0 zsxSyghvSk!Jkah*W*PqgXYl_38k$W(Cu?siU8&@RJNO`N$r;9ajD2g(bnR8IGfsbW zsj2Ie+Cw3VH*cIS;@J)WCyZmKr{`IaUYFgtd2ZlxfUfNR9e>U%ub)awm{xff2^1p+ zY>lms-o*a^TH+$mCb!ijh=!E8!sW6RcV|AGy87b1x-o|>jyjHf!s;;E-P%0x74st> zH@PKGA53G8-&*HnvADZo92T)Ok(O5)bts(z`DW z=s#<}hT`l-u|!#!7-x4}FXfM=RM9MN?yi^3nYq9KDgANVitUocEbZqms;a!Iw|+7D zf`3}e5m}{VX-1O0$?WvoK`O9`q+kn~f^+j8r1a_E+P0ue3lg!z3~38<++h7XRz{tx zTHFngKGIn7yc6`#VNl;a&9&Fee8?Gt1{@GSz}J^H)70*btZhlDLvMGsKzUr22RR() zBij_owFq9^u^>mcB=$VC;GaSI)-Cv&8yO~sNsF;0uLr zLosVQvU08kOM%;qx zrCb199N>U^{eP8WN2o@|RH}E2Hiz=Q#(T@iofpQGcX4h%hX> zw)+mhTFzA5gPO?bhP`P20DfgrpO+ZO&!s#2MmM*cEHTkk9B2H2UViY*_WpEiTMRb> zdw-EvR$GXyU0n*utO;Ow8;95HRrPfBOpk8%W|gh^y3`jED#a9mnY#tgBinJv{QYaI z(T#K{HythO|0eB-DdYpI8e=3!QaaUvd#omW-&of+kX$TO7%YsHu zct4F}HMO)?QY4==j>NJNjAxQ_>E5<&UUL_i<~ch6jg&lgJ^R!**6VOQ#ZW?WR5nP( zWhY}*s9ISw+xcjcpac$i^!D@z@vd*|!rCWGmB3quA1McKB#-6a9V@Z0xQ!lIvG};xZ5hQ2P1*g@TE$23C8CsrfCM(GX-fQnf_b?PTsga`0eXj z(a9y1!bF=FX)GHbdk2s6?OKTp5Zf5j0RwMQpY!SZ)f=RYyaW&3#e!V)+tmI*({pX= z3N}US9Yy@iG-NPf0rsiOrhLFNm%#J~{{Yk~pk+d{C^>FOJ-`P8_5CWAt#Ht3%E7jS zF(mfn@t@E1r5QHtIV&rd<++qu$|J#UHjc-S{{U4`^IBOC?^kMv3NeyEIIeO}6^mJl z9KJ{!d*F_|{y(Kp9=~hn4eAT>01h|}f;c|Ly45*a?HulLxxTM7R@^y}u*5k~0LB2$ zKDhiUc=YD;46;b*tb^um{Qm&@s+F$45`BwB+6De1cXFo0*4Tcyw9QNXqP72ozB=2K(OIvoAdw^IjI(Os~ z`qhDD3x`5*r=OH@j8#h!{)`KzS0FKG$ph>7cd0LKYyI{8$T_*QJLg}@O7#{?0d^VYPUcuv*;o;&{lpYw`>Z!D`iuRN3bQ*!eT zQxf|^igjm%va=D)$?9qWtHKdu z^AJc5Fn#|3r&=@>j9EM__G5C^QaXl|O%kE}!Sxvew=Fc`8mfQO%4sigbXerNO2M|M=L0-` zf1P#m$W&rQ``s9K>-{RtwYr_G0K*@gj^?U2TN3=vTIa*;u7(ySCQJec8S9h!irluf z5m`ho6*s08m=Dx?R)a#KHdiBZ@;3IW^QyhOsBpOegHbm6mlQ(9B$TXdK|e53I`pW_ zTU!ybi34N|<24#v5OL=G$EyxMDzMg}er@D|$;%FStnOWjAbA;CX2~G&k%B7Vy;!6P zk+hr-darFCnHMDW`McxXR2P{M1;IJ{-oIL&X)T9j&6uPNrE}XNpms$<(s$rhDDD2LBQI1A6l;3fRAc6-G`yEz8Wx+jmAA8Qp`|wPz;Y!$~8jj_FK)A;<$D`c-?~Mm4r(b{#ke z>Hh%hu5R8^E&z&CxQy-H!+MOGux(o5Szc3yB(6sTIsU)StuEqh*ool5pYG&gm#-)K z)K?0w;m|2@(Ug=wpGxPit}ku$=+sAsgzYR3-vLHCepPcs)FITZ+9{@vIhT#0im?29 z)q5vvqIuQqX_wl`@{D)&Qaa|DIuhHUZL0X)o|)`_&#hOxY2X-guakt79;49ub^R)} zz0*${MJoN=m0^*Q?my2;=aR9aX4}iMDAtkSf=1!f~~`?%nKVylu;*j&jSOF4DSi~|4%UZB=Z#-L%8 zq?3h_P`2Jc9Dj{sw~7`yOKeri>z=*8AO5{nzt*C-ibqEIn+v#(anI>j3KPDlnN*Fm zHy2ivT`UUB%^QRC8OZ7RS4M7)%m!5qSYU8HYtO7Ek)v~f`*{Qm=ZfiUHC8bO7{>|~ zfynd++NyAI*qF-umpthul0+z*iwvpic&c}{%p-3xzjut159L;G(bDD_qiFzgq;4Gt zagqINLNYF5Adpx4wKuXIjzduw7IVvmn%EB$r~FTX{L*fbaf&YrehG zh-|JdJq%CGlqW4A`Ytq=ya}oRdH=#W4 zQ_~-vLvP|MnXh9*xlEuC2Y<$_$D~OEM$@1UHz6yJxFCFUer85wuo7r7wArT2BONclOt&X@F@;#zsl%2fb-Z%QctFDuSns zu5{4wozHu+`uoa&k zm3EfS%0oXKD9`8VTGPC-SV&$l69kj)4mhUUT_KDxav4VAGtc8tl&n?Jh4yJd!E&T_ z$4V=&O-jRJlxRPCtQV70qep8P9GhDW~*LqfNw-;Z!BgZAX^XXkW^fOi?y0MyFE-OgwWaU63 zes&yj&!tn+wEJBtt|yiPlg4nVob4kOr={QPw{~qTaYl$fUz{AbeAVChMQ(K%-KM-K z@(|d@0*?Oxoe4dL+P&FH;k>6g-Hp|-OmHt zzxg%kmUg!BExZS7Np86f@19TNQcGn3^1=n(yK{S=>)xs`vecJ7OklI6gc8b)J2MQ9 zNay-;PdHE}t7E(iYE(OE{TAUHMZQMGX53V_>Zf2I|A1_Y*&Ab?iP!2k0jQ7bO zk*D2ges%N)S=sHK%gG)`KF8ZNphR(PjuaaZc!*iX09{_n4n@dj9~8UDPk+fUus;kwF_KY-|Iq zVJ^KicGzo3^4Z7G91Kyb9*EYy)HM?86{<*PkbdlAfHTnNzaOPdX%Vo9$0Nj&7cwyi zg6w%C@!)+cHeGJ{*dewtZ5!lN{_n1TFV2Wv9D&ed`c@o!Vt~aZ!Z3`I(lc)F+M}LD zmvr$m$Fv=aS2@5VBo6f)-HPNc>KfvMBo3c4gTXx%jDPk202*P`zDQ$?7~=>4EHkj+ z4!?o?E1s6vO2^H443fxWjmuzXlb%OIP{XU3;Z!81>|u$)$0N7kY8-K4ud_~(yv?Yb73aSL{QK0FTC`e?-|;JZH?I0n(}BAZHyM)a@qc!d;Y%lpK*HcDT#njB`}CSToO8;On;M7 z>UTDF-@b`eVj$tpN|XNp>(5%|?=Pj<8QHWBfc4|OXo)sPppvS2uG^S`=Q;Jx57!;) zA$Y=7h;9IaRhz4H{=NO{oo!DMv}5Hf)CTLGzs!DBNB$Crf^<~K1b`(io-@#Ue^E{p zr7=0iCvWzqm?1MWA&+9PWBF z$$YsaXCpr-I17(|bNs8E((nBFzFvD|j!$kY zXAV_nWTkg>M|XPYiWycl4U%_r*YWiFb6D59gzc)Ee3cP`cMksmE`K_+E~Kr#GNwln z?0gIYGyX+av1l%CUS?!wT$Utbu;c##*IBI{*`w828uqM^q(b&H8iiJrfy{A)BXKAcuAvwx{FL@hD{ z7CS=WcmqFC*Y)?UX~DO#6Ou@h<66{h)WH) z0rd3Zp4VEOrG)SYaHUT5!N&yTde)Vunl6A@l30XiaS!sS&$nK++LU0f&Su=%nz3Bn z*%d>zQ?A}lG6(>EwJn@v-3e|W^J7)d&byBscE`1C-N*KLW)_ov) z%F_8_KyrBM06ydOrz%eV^SCODqB_s`N};&8l0=D%NLkrbXQ0XH+OqGwMzX8O+mJEX z2T$?1kF;q02J5z&F`$fbrak!Ho z@dm&>Gr$1<04nq?H%d$Eb-J1mk}PFy&@U)B=ik5QMBFL80zA?=32yFus4fbtyRT!& z=bR6~Rg8?2=pAkw5r zll>s86)c?z&mWaXv`?X2uer-+4iqkHV|#x-3^pj|!6H=LGVjt~vHKwPexD8GInTaHKczBR1lNlx3KBL}_iXhZ z)hSz2nSp8H>sv{h=%@_Qk+g%3IRof1NXw_%vsx4dRD@g!zg+oBz&T~eBa$)y0O~a9FJo9) z5s*fNWS)R?Q*?)Gl&8{-yir?6C(DiOTa(65U&5%{+06smy~a3Au2kfl9QE|z55(5v z-YUXajl{-s0N{?FO3S>ulG-T5(h`{lle-9taisf!KM}){xw_BDNb?OiKHB9T$qO7RpqipO2x#081dW}bPdPH(74aR0? z!CU}A>)XH)pdp41#JIfA-9XW12IQ?s0+fi>SK)G`Yhv~s` zdJgnnTQROu=Bs%2*7@An8BdUQ{{RZ*F148!c&2maWR?L}J9z6|RpZL<8qKuFfswa4 zIQOV-G*JXc$Yl>DsPp+7L_F;*9mabv5GVv_$@*=RwB>H2&Q~1?=V^@%u zc)R6_~0)f5%~INn&;)5O)ASXCQ9v8AHohjMl*`qofh?GQ>)P(e}<-cVxLmD zWnI8S99jFo4^!BapTJhq{i6PL3guE$yRLSsfs^^=lOH#>M5Qh)M7^|mUblY4tE@$Ki&MZ&(LARsoYN>jZrr{_TXTDLHTs9 zx>Q}RbJVJ@V|_HSa~IDy?&JbRC!M3P{7rQ_eT+H`9(R`%jLWr{a8FzeeGjE^3*sAy z3oW|F!0jI{4hI9j(yk@OqdmikrX%-WY)VE!^!)&*I7zEFpra_?L(whuzbPVz_jm&s zW7E)oPpxF@y3saW4NvBEmA3MUS}Rp@i1eC=nil_h^%FysvWvP8@z{S?{}&J)lN=-twnWj zv`H+|Dk?_V0P--y`VM}z1i(IhHI!%$ z5=jZ%p}n!6t^qt&qg%8wIgMA%*jI5G=M+6&fwD8iGEUJosR~C>%f@qqpU?T#%Q#lv zPc4~&EO4i$G27dUn$WCV6aK7j$vkooU(TI*w{#_PB*`RWpd$zQ(&b59ce}9V*(c1( zr)fPsx*Ccp(o1<2xMgpZy}rLn&YJb3wUvKhN^4YdeCWk>U&x0Vg;B9B1^+X-j<(hzJOD z13Q5S+xk%#)J+hx$rOwmCj$fy^(OX>3nwZ7QI6d4Ok*P*pndEE?~n3oNr^)cKnPKv zm!QW{{OWb+UY$%`O3>cEa8$TOJb}jW~B(&7{<=ze57(Y>^URxu6jKp zZAVU-?P5n*!5hntr>;rHF`kv^$sMiDi-(OK-*_&dZ5RV5@jO#BdpMHb<)MKhSskMZ z!vYR6efnamHjbo8b8dNL-WqsCw9-hzGxFsQS8HK%J%bW+T_gukw2oam;vqb-TRTW_ zK~fHQJaLS3{?&HV>2`rO7=ywSg*>QS9Y#(MwRKn4w$kcG zIb#b7JZo+XU=NoBA5MRmt1x(G6qZZlmW+e)MA`M{o}-}v{{TvJs~c#w5~nNfa#OYI z#|-ZnMsyqD-bfwBJu)-JXc&#W&_<-ANfWjuPGcxeN6_QHsr0Q`-rjU0%ktgwq=E|* z*yGcu`8A&L-N}AhGCb=iQLv1&e1x*&oNybDR==Jd$d z%|(z&1e>-NM{E!}gV=TbIPY2(&@9tU41|>lf>#)9@IM^YTg7L+bXoSo&6QAxft-F_ zv-Pb#F4h=R?*T49c>6kzGCiuLE9y#C(5*It-fVMPCze1YDfaKhQM|gk`&z*)Mn_Zf zl{}CJK=rju{b@A63lXcm^D6ESx-o;o?#Ki1{#DX%GTef~IQiw9_`Y6xf1WAL zewJ__I{*So;Bqlj%+|$nr@7A^4ejOL>Pn7Fa0nP3FmO&zG0$#kvgqz@tgc~3DQhb- zM%*zQbA$MU)6`d44eVD|{%6cYiZFQjcO+r1&GkZ=HlUWr=WI%#fZpw&%K(G*uSB|5xV4rQk<=Zf2wdRu zD7Mqm-q9m7GkI~~vF-^U{cp;x;w0l@RT$ppHkYSfM}H5Tn~_s^kRQA-I3Rsb<qMPoUz6jkO$p4BOjJ4VjFgjIFokPUV89(;8I6(7o71v14el`;b}c$biixdt%xhRR|cz%5XlT z^!ir5i>6!%V`B{Dp#hR5+Qc444ToLrgJbdgE5r5O2{ zSvnHf+DE_VQdoGUm89TcE--lA^vC(;x!c^v*(WOe1|FQ?fAzHMpw zw~?*oP3s(jY-NcfBcF5a`PP_~5mCIOmm7${{P9}-W=UAj*rx7MgGjSFWDrXh6~A|p z>(Fu2nq{t=1-uf+ZiX`%$`RS~$sXsN)Ug>}BZ9|kvnb9u?Vnni-G#~&VXy+&{IQ?b zvG%XIuObrG%H1u#NXjWsoCE2eKhLc)M!NFW;xs;4A3F6Q{{V*-C9GEt?;A&$&ejLE z>;wG&0F_Q65$)Z$oM7)icyrpHHN|Tg6Y3LN$+gio$To)C#!mx3jzvc#QtI#st|3Td zk0%6@02v>F{{RZvFvBFMW{Y~SDshHi@+xTTqE;6w-zieO^y^i1(49_9_-FU3L}(gd z5zHjuHtyi|#w)0b%t0CR8!UL-2R@+m;Edz&so7wU%bGPT2W9RlvrK0P%Vog9!w=Iv zX--_rQN}iU5k(3o$+@^Wz~KD{(x;K28(p!uf&&j)%9`a?RZ{QQB}x0I+tdF5uUFkO zY6N6%2PYtM2;=&S!uK>OOLl@UnfMLC9G-s~rFIOq(h}!8_Xbg(5B~sOrkWC8&1m)+ z1{e}>tC-D9VNF*FC$Mh{sz4dKp)j4!V58Fmf0Zj)Z%DU#(cTzb$L# zPC@`wLOJB0U&g9x+s-461ANL)p$qrFtx&p2+B;a`1xL>1I+EG>Kp#Vo#<~JTV$ta=bSW9wVC`lND4831i*LX-DOPnC%4{yF}2G*++#F>lVyl{n;7%FMAZmIE$3p5Spxkp*%`%DYJ;r}^ff zW9?uP+da9+*?_ElD#TG3VO4Mg1M_3_H3U+S>{O5m`=gp!uD^HA;KXooNy!Z%UEh3| z8=rzW_o!ZIf^6JF54;a=$MLM$Z%#za#aAEe5S$Ors9b8TG6r~*k$2i0Z?(l;QETgx42;_Lcbs%d>#k+`c?Fo&Ie+Hk%mxuW4Qb) zJ&HCXlgMQVRH^6z>rIu?TWoCwfFm6b0;s@AD1hV;#Yy@T{OKgRjsz03efHxA*SGSa zNGvaqO|KZ*NZiEodQ;`u6fzLoUDT@kcH*nWJWXt4Ry$+q-`=X<>TnlmP^n}j1@-z> zZnP0utzGVXaMYmnG2GfLN~6a8foSDmvn{OT{MF5+K;bo^g@KKbWp= z-od7hS%1|MFr^BdXN>jFACFqK7ur$MAcrWwF)NG?x%yGcyOVZkrJBzy_T_OLz-@jG z;xqUW$p)PUk7yJIhvpqia&z^m?ICdsDux3A)Shwe)}>h_04#+@@8SfWbNs2f+h9>4 zxme@05hyOL^7(Rbzs{@uiKdP=goR|zLBaY1^z41BR_Zd=x!Jw3gSWBB85yXpqF7}O zxP>dmPrpB?FbA9i(TVNH z@-?olF~V;QxGXr~eL)_d;Z4M& zk6(JVRYjs)Ig#ZWhLLnHriD&64n4=OH5I&X8~GB({%1cn?!KbC`~5lQX^|w28cqYS z#>F50yw^8aAN^{AT~x(@t`q`( zR?dEuozQ4&-^08{(P2pFagp@LrDwpeb8##(l~+@M;C1yMO3pgNghge@R|QCHj!&=S zT5xJG$#4$BGBcHa2d!%vXhwwcto~sJCE5p3f*5oe9qS_h0K;%y!qJG-EUS^V4pjdD zpIYienW6bgD98jKN`iKtDZ?WwB98q-6r_(iV z%EhguWRgO};H#04Nca3dTItXsP3)<>a(Usu&%HZjW;}&PInFRJJu0PMPjM5 zsOks=D$1q63`Zmk{{T@%71qoa*E(ApnUdBtaEhm#sQocZHnQJo^3;~x!;YAuiW6w7 zEy%7lcY&0wLvx>)lhe|x!Kp~H8Krg$w~qNfriv>$PDREjl1ux2hDB565<_5PpysJh zs!HuEMgp7{1-mF50r?szp~>8QsEIW>OKmOt;mec!JaLM1-!u`iNn{E@VoAyApVEpb zY*sNYCw)rgM2-nig;N}7-l*S1pK58RBPDajNa{vtqK4XbLrGYf^?PVwWmsFx&fqvc zopakD@mUghrbwe;Lq{{7HuJP|!1SVuxKoUtq)JU}R+GeSEMg*x8M#mwiehTAFe(Wl z4&$G$Xri*K6t)~>*$vjEEb@%I5cmNJ;Cc$oy45jbumQd|!8qg(Oyj0cAB_}MQG#;R znv!V^x79`6g4@X;MwU#89I*rN0P%o(Rj9SGY)z{~(#lT{oB&51JvwpHiYvA>qp^oP zt#d_nD~Y3I7V$d~xH}?(xW;e?*ZeBHcXD0IAS48Dn2E*pGq>O$@uXRausyC|h&o}+g<+c9vjC8$gvFMOD8c9EXHN}Sl- zU)h)WQ4nPm^y`8AjTBcrpDw7?Yoj1rJN+G#?FCuepOv$m^!g5SQ)%dzmopoix5Aul z^7;|epHHWy6j0lgIiBE^rDEUNrH=%a5+T83&ImX^hcvo|jQU-?QK4}2N3 z(s;JwcUUeC=ugZ-j`=_Rdfv9VXN9LisJl0Yam!~OpVo>hYg3F;v2>=})Z5c^R+8c= z#E#1#E3+VHCkH3n`U=$4ER#;PGIKk@0Z7DvVVDwFk(_kdMHS__xlYXONhsXp=d*jr zn(tD%XwVQA-ZA^V!`N|wk-+z?>kkgZXOdXh8*%{z3=rAC$LB>A*%`?vW1Yn|bvi$U z-gz0y#(`KqI}k^w*A=1v00^`g1w#$8Y*ygzBKawnU|h3_(xIfwi?@WGf_5f=c(mC-vrvDPHV4 z44T?+v#hdCTMP3Ypl6I8J?d825yM6TlYq6OJ2;JM0#S~Bs z#nd#Jjg)Hx7Bb1ZaXn5qVDnfbMAQzbH1Gqml2C8JAfK-t=%TJQ8Zwjzr zRUOG@6n0kULt7VJ(>$SHcR3{U&)|Ow)X+2?J{aBF-{x#DT=qS`Iw+;g_8N*W-C98e z4LT+mXCpZP`+YN9mGp0@-tgZyk%e-5bIvHDu~KSREv+nPX`UOBI~Qw-735$>(xJEj zU;=m<$T|N2>(;Ek8(6GkVH8Nm=Q19Odh^`z-`a{Rr`t`*87gr|%+x1cBo%@pvN=3% z$ZYfNj!k7;c%tdT)XF zT0Gc=-0f$Gwll^*KTQ6VQC%~eR!G7zPgZScdTqQ3=gv|`ApD_D1`aX$)~=(h!)F4R z)HJdulNj6g1^^v@3Mi~C&pl1A%MA(;#~ii|DvSdo0L6axNcZ%uO+UlY>UQj)Lmbdc zu#mVex#u|g=N`g}D>=!l*tn$ab9Fop8KaNw8Cc2(E5UAhpU$xLi&-tTxomKyRf~+V zB#t@HW5FMXy%bc&P3p%erLktl##rQZ^O7d>c9FE4;~eB34oC8?v29>7%DE+QLHd(} z{HUU`o4YP3eZxYTp&$OCMHC=q z8;hCH-mDu~s}ic*cIoapr#n8?egjJw!5`iuKhBCNFhua$TuCk+!B-z94_=%f*P79S z2%@uJE-LRiYQv4vplhTwo&)6ILXv8*5O!ZCDB!}oPo*0HgW0y0P3!DP`jEd_|Xnzmu~o*k@rYE`)41C zqKd|k@gK}n*uUZV-rn3o*~-Y#A}%ljllq$3I-HSQTt-xnA;vI%_Zj@LiYTs`q}9ob zXt5r&w?ITj8gS2#Kst}otN#FM%{0hE`D${J;AD<6KR`Z|QCPw%<+(ELt%^zZTbVAH zFQS8jNh`?u*2T@TM-;+L1lmg#9X-AH{z8f?OM#u|%>e*~e=vfa<2`fzD)`iQS`Rf! z2k1wrI6XhlG*M7di>gT@%^E_%E*eEe40!L{cg<0q&CJQ>fMHhh&U=gwe!Tv)QAD=5 zmgbeF$gG+Zg!0Q3Wf&l5{{XLA4GS1D+&LLy5BdK9B8n>;x2dIy$-Fv-azZHG>7Fo0 zIT4UGMMYSf0(>Ptx> ziN~0^3e0k)ZpKW0rE7EZeVx~F0KVhX0CGPQ`c(-pE^OKhIc3b*W0dDSpJCg# zwG>d0g;kREZWeZAV!NYY2LOfV{{SB8?OD=zc#E>~xDByLTxZdL&*McDoSN8nLQkWW z-l~FB&H*7o{Cn_0u5SMTNtWs;JqchF zRodyn(Q?a;K&PS76xtlUTda_@p$(AI`=G65l1!RulS#-VP19OMTv1S9JrF@asGN$3 zC*Up$x^jskf-bt?s#sAxSn*y~_W$0SnPid%73+%sE`=mBZ{GXf_kHhs-}~P8zW1go zso~afigBCUw|L*18=o^d`oz&|ubX{ryjh}Iw|C*yvA6Y#pM3MT9Sh4FCjRpe(k-^6 zEyMOK^-SG2f8_qt|Mxy5>L zsI#`OY4k0iZ6E$jI?2{!e$Ak5V;_R?+I(=t>pFUuY4T*)Q>Tq;KJ&e-QeW|FS= z!Cogb0iPpUs=d!OO%!>0X#f3hMc&=}>zIR&s@ozPd&g})mD#ay{fQYH*`_gnQS|J+ zd%)G6(ZKgd%ddHoHq0M!;Ogvc*M7CXW8s6UrFG?B5AM71Lu$gh{=@G&*0%b>8;iCS z*wT8JWWMp8>{VSPx%mC8Q)~bAQO8popG{f4_r}fZuIu<{&D^)f#eMNIL?1j&R!B-HoMGS}osJl}KU z)85%Tc2tzSQ}cnO9gcgCmOX0Bm~`T{p<@QUR?`HW(d_TvJ8tWZ%i$fyiBHpKXD@l? zi*qZ#yleGS#kF5wr9Zyo8TuvF+Z*WU!AC8pzF*<`W=mA@xYXr)BKzKS>yXOSMMtI| zaMaCNdADli!iUmVFRM7WcX_p>f917dt8ZF5q(Zl%YOU$q-yX(*Y?Ig zMJ}P^*c~UYR=%xf8DU+8$GiF{?#q7hLMJ*U9i z&USwTgTcX=s}epvwCMT^O*z9d7JQ>qMo)?HJbwCbLl3^>zV_5-(XZZcX#d*VGb2Xd zXkIw+*o!Ys@O+syVf!oOk-C#xGFP9rG*5WAa@@x4fBkyvJ-JWc^z^nx;Ri-cdd~XC zmIEWd?pQeS<1sz-Cs$NfhF>#y-2O7ay(*pj;!O!CB=6p z|GD?;V{XohJ9YH!M|LhY4;Xp;(^liS%wEqwJ*48br}>(OLUMED=T9fyKD%b$g0~KgYknhBQX&77 zW!#?!rINf>ikMI*m?LUm$l`}rj=JR{xNZ?J61&F7Zpl${?X+q~;Y$7}aWcMe*~?uR9aHP7DK z5g9&h&|QmrcPw1C?Z~nZ<=LZT9ZUam)4$&;njR4uEs^w=z+Y^3${#YDlyHSUv665J z$+DD-RWz~+6J;jdR+oZSWikqiNh&XuH?np{B59MdE+@@2u+nUzO=_X6Ry$lt3-Cpv z)MIyAO(>xfU$nOeR`~IsSKpTmm7!0pB z?PR);=`SFsS{!z#i}lkC#oB{0b5f*>B1nRvJOXwyk}(kuw~L_RKjX3!F5om~ae}xs zVlvPFoF730@m*Xjiq7VX=}d_M53JdQnY6N0U@A`qh-d)rp_>vhTiZez-9Qte4NwUZ{wB+kbnB)0;? zP|v$4uoAA}5qUgs2)kJXT?~^K5*~C2f$;OxSIl>Tdj=}QikZn0c0(g&bP+N?3wU1E z*NX+j|Jc`8%SAbT-JLMoorHyS z+U$&1V62E0p(-^&rGjY5c;+S&NC_wM(1SWHbnw_vfb4;#6M~9G&BPp+bBGr??GDQ6 z@&=Yk1eHlKZX4w!4OWU*-Uy3qfzWo5d1apGu z0(Q8(4hp2V)N3=?twd~24iWE$Aqq8+DV`WVo_`{D*-P=*T}Czp0r@HBaG=Ei5UZL= zs~fl!&ruam{0MV?s)Bewcj85$Q6CNhdr>wU1ubkQn%7os^m3Dav5ACuLjGajmh6#{2 zWUl^%{4!$s<%$G}F5(hD90}tiVl9_fBss)nQB_ex_! z1U)8(;{w|i4ipaP451{@B;%+6`65BGxSNoz!#xrM6hRlE2nvrEV$fACJL+(93(3y( zFv2h>M`oL-L@2!M;uhe#XriF}#8UQis*-gnAHW$ACV;yi8Hd|orH%C1b9~u-7uYnL0VX7j`7Wnd(ErGA=f$5lM?@v~2O%mHS#o|PkQS24d67 zvfxJmzQlHi%U8-?CJw|-sEsBF)OLizVz*HWx53T0+zQa5xQ~|F-A*H=Fx%K9m|ZXm z^u>*Gl-J+Oe}Nne9pSgF)z^EvQSI-d%Ms9GvCwk0mq~7}RNEa6pg|=TEJgyxNf&Jt zX3k(*!X%fNz>PUw{hx_KMr0;N^Hv}~pu?!#2J#@48|{n>#!bqJytj}7X=W?ck_RqK z>`R4YsnKqA+Zbsg_qfr`x@faE7Yf2yil4(T0N|gKR&f66V3Kw;7R`3Xn80Sdtol2?&M4#2QglLF2Z}(;qTW#%hfDK zsH^Ke}cUZi=6?V1eVfn%VK(0 zQ3Qdki*6T8)Aoc!;gYw~yD>QbVk;Gtg~JL92)`#o73K<84At(8T9>=*|Cp^R?nD2t z%~j}lSIpJR-FdoM|9{Y8C0#CTt8(TfGT_kYZ=##A4IwpJA%tTF%_5tCGX{|n$eXxm z?88>5(E=_PCxy(yAd67|&)aWc6<{YeWc0a7kyDfRg2`MKnw7`7WW2kYmE(AjcvyOy zNW{axi3FDgTfGUKH7GVY1pHl8i_2#Og&+c3Go0znV^)WM5yW46I0rkKcA#L8U*>jV zU}dSEn{BWP18JbFVviP%90Ayq!OlRTHZ^rQ-OyH-XsiUFHU;AbZbpPh62&x+cUavG zu=;!XQNnm6L97bHB9CYi&&?#xf^KBTqYId&usJx=fp4eF?`def;@j({;=EG)zmx-) z%^LM<^UI`XgNJ}Cnjgh%ITaxXqf6EN-DuO_!*FrM(El%0cUQ>jHV6JQb0}dJ!$+w4 z)(8@bIMU$|;*sML+N5rX*F-@$MwfI_bTl8+z{S)FK@e^C5d zGz$IU7anSSQRQ{82GMM%O@wk%G>TlQ=VOWZr3n-1B861~Jn?~99&%sfd7qupF*L*^ z3e-S6Axc0qGdwNA(=uENpmmv};Sl|JzzO;1Az&mVY63byyRQ~Ltbq%0;W=0cahhDU zFwbON1Q()!W}r}YO+0ri2Uj>Okw7qukO0gU-9e0l&4Hq*gvS8OOgFflcpV}h%~^#f z*nKX_$*p9F5^R)-Cg->*rxzvKEp}E8@%=W^Wf#}q;G|8WLNE!!OSkc8T8Uc2MM88R zA|XB=QXuAB<|j-}Ge)Z$BKk!vkc0Ex3egL)_$df1%z%AuAwUWcFvtfi;Ab`pG*RXz zIf$Kd)@|Uzzho*Dm4zn1{DhlBi)%R!QPu*{>8KRoDgq&(qnJ{2y}WLsT!w!V6o6Zt zifemB6qQ`qX#6vXii_ov{rL&P0AZ0$TvbS95kI(Z5ea;Q1;xJlp>$y&2Lr+3i{=26@!o|( z(m~67G~fmZDh=xgNJuz-LlhP8p6^5`x)?lM3zx-d_uw51TBj3&4CALlGgj#Na9M~XM7|)}fHnc(dTp@q39GO!!f2;jQ2)k( zd>jcl4vZrpkpM6bC#FD76j><}6e%x`93W9S5R6ID?F0q;6>uku^`VPtD0o`79W?yOhT;)Im@6MKuNwg`0DeqjMD(VjG_=#f!ktq zFt>ccr{Ir+1>vAZ6m~*@?BGiHUQXa}NgVEp;@?rcXCN~E>cka_=&wQL(9qJxF@VTM z^kIJayN!t90W=AU9->Z#&We<}9YUx)q?7qE2|*eRU}3i(9{LEMxERpJ7y+~#cJYu5 z1Wu!k7hFcz8bdO?)M0rL5JkggJK9`x{)Oect}A($-@y0B z+x-`YeEm8z`rlC_{g+P0x@$)#io$Pwaji%};2{tjHNx6k9O#`;fw3rjhj-F)Yve!q zeTk0kuCby&S;MchSkG<8l;btK%Npn^G=YEF;&;)rqzQg0!O?{O6C&b^o0RkN0a3p& zR$U2%hCONgwrM#Egcb`2UUa*x(&6_M|4ilai&RK}+f(ctzTy}D75&0O$7}3nzYCU$ zOB|Oj+Sm#-VqIAa4&3n(z%5~U`chW}xK4Tb2R~Q~PKb`i<`L&KjN@HCXfqsyI5Kdw z22zJG-><0?ZP*L&67gP1-nS6P-*QvJIBbLA?3|Rw$?y&TG;~qkfQw7Ojs=`w050Aj z2QG%dXS`PfRVl7S@NIzI7cxHzv<#JBE|@DqLE%2`BKh%%DrDviiD+=Ea=;D3$rcx7 zv2QbUqVEbC2c3hV0Cxy?#oxewF~vB7^9Jg{MF%IHl$XrN5&Ej!MmhpdG+8pLwt7KN zi3EN6!1*Ga>k{lRI4lLu193Q{L^k@RD<~(6Lb1^;5(2a%5<&&94-^q>vWIO&2rAPMj1gk8^YSJQ@0 zIKg8$MYW)$8+9pgah^uY}HoDo~|oWMm|(G7_bTDjqHlGS)*-4a$Mf zSHVTGmo1NmFc6-pgj6*lIS?u?fj|XSjFKv77O}t3j)M77M(&&zn$6=Jc>bhDHdpAf ze$K;gJ*dkDt&|5oImirc3jQ&>4PyEE6yS-Er4Y#sp*3(M3^-S?=SMPd zr49s1kgRE?P{57hXrW;Ms6c9aA`(p4ckn;VZ6razkehk@as^^1bf?fPhL*sx9mM)X zDGho9w`m++z{tk;Tyj9?$V`-4QBWC|m+xaRnmE1ndgy6tZj&`ofpY~EO-G4vMv%p) zWrU5VkliPE0ZN7I?jVG6B#%6BUM8DptCjDgu%i{aG$(c3wVYE&a z!QFTRv$Tt4l-FQ@Rx{U4eIg3EIJLyn04Fk`4FjkO6ZoW^cF2izk(CB5=dFaT<~r^K zBLRY-!f-D{8U;0nk4&hMyY{gNvsT)kD1`wX>p35z_%RWRaK}Tz(;qz^3hT_E|8*K@}&7NNnMny!1hxLH0 zJ$m}HhOLQ3;Uo#;nk|LV1I7>EC<8%zpt`f6L!k98+(u|k0mKFGK9Xij z?QA`qk3=^4831fs76MadLJAfJ^oF+q?Q3FBc(j@e!(dO$4iCk?-nQp2s zS6!yXskMw=r^}t0mz%3LBsZu%I*qzPr!6ZfnpNJa)@vFX=2)5QP18_Vp;1?tshbLC0)&!ckG7#YucEkky4K?=GUivfOY^6C4V77Ls!TgeuQBGU zRpr{;7JYG9ipFYavRI5ZRkMLTZ!rQBsItrkw}OZVhklFe>|r=ZoFRpoYhn#$Z&y2gSkr6sMUmZ1u%27|FUS7R!7 znyT|uE!DYIvvM`9T4z)BbSBeYtkW@tCU^1-Z|hXMO6MuhQ=3t17L@9>`FZNfTBbo$ zX0SMo^i)^*412jdC8e|?!)?}1HIq75NvnD$&Rv|TQJXWh8nr%GldAR7K9T+mvjw0f(W3JOb9)XdabX1ijd!J$`s@^f?Ng;ZyjEAp*w#@Wm|vMRk) zQE8FR+iWBCE%s@p>PC&ybE3K?7C9CIXiV6xE6y+APF)wpsQ;9Lp zTUc(L?wVP_I8zFmX0%piPRlZ-!NCPtt!z#$gS&>dFfT-R@%Kw!#UOo0wUDrBijv#B zpjSkC5osAS?1^(D9Uz4cThA%PdU$};ICN$k4NG!pxPl%I3;#IAgEA!rJgGs(803RE z0s!M^qOp#0GNe`7zGhy}&y@4RuT{+HN0PHmMS?##osC&-9$pElygYLUknL|g)!4s ziYVbGFv@D>;GVrO8^XhQenf=ziqJ?RD-VZ%vU9@|@58HUhaR|Fw&KyL8MpMiKPK#> zM<@K{&Ua3{H&(wXHfg83X8y z85cQ1Ic)Bbzs=t+9ri|_wbQqsyrymE7d_fLlJb@PQHB9wVgHVdj0o>FS2+gV_m3PF zIpk&X<6RqD3y&RM`s5!z?eW7m_5H$10^2NtmMG2PD#@0`TchR~yju(625CP1Bem1g z^NFig4fIUC?uSo1?%)2tW{K&9`Rn&Ke)Zm>p6RnMJiH2uteM}~`u7Wcv(=x*)y?P; zyKv8jxigg~^4?uI{$$Ch-C?<#K8}0xp|pW5n=i08c78D6NsymBke>s*{0w+6^Nv7V zl$LHbolH5NYr2?=HC+kJn}dW%m8!}V2@$^i4KZm}4)hC8kBK)&N~946Nu)mgr1!3- zez&YV+i%+53o`rXMzw8v+s>puE1P$nsjfa!^FYUxdH;OoXmw=%9s2zH9rtP0Z&~xz z&ieCZ8~XM?X}o>O@%%v#-P-S+9qT*J*AG2EKIRVRNg`oPFF{4-hKOWL3rzi&? zK^cq$r-w2EegY*atfxqlhG!34`^d-}Iwdo=9JxRKiTh`H`o9v`dJzp0r72wLndOOB zz4EPR({;;My;=3tlCAL@q8ASHh2BgfIz@vaBLm2r>6 z-Da=bGOkz2kadf`T63pz+GKCu_ik;cV_oyAm0u~B&6#b~Ea{@8>4O>s7j8thU$znM|x4(@>yodg<>J-YDVy86=}tFMWV zJT>aUFORxz$=$lC=Qod@jUV;$oA>m4c1Om#8y!^(_T6~3Aw30zF?hna@f4lKivLK;UZ_}V)B%u z+O??RVCsXD-j=K8h2?^fO@?WKvgtQzMt(#MoPn&Nl_PvJkf;b%AKy){Fy(09O;iun z06Z+Ft6&O|l9`e@OR4ZbjZ{e^3D2=%#!ad{)n~(>T0e1ic1+cZ8_M6?ddzU{t`{Er zYv%2DD5HI2d3a>LQX5Vt} z^uXZ>4eR=XodR`+r$Ezf=k4)FiPElp0sKlxP-ToFz>L=}!zs-L4kD8@B z+us^7`kk!jwckpbAOEZ6aE~Jq9eavnS6zR-wa}P4KRzO6TT5B#$;fjhsru%TE8kj^ zQX_lr!*?`m26xv!IX`FXN7S5wMcbA+=B&8mPjB}tt{N5CR$Px)NgkN>+E?it=kEX0 zKdp)TruWVq*s1<{*_4)RE$VyskGaG8_jBHyC+>T4Q268{tYiK88>WOS$4s32R>S%V z#Ycytv`2TJwyt$a5o&DyvWWSM;HP7_TKG`#m$H!mAj@l3JsJLRD_+}M^ zU?^Q=Y`J2dTrp36?u6|kB6P((>7IFl=2BCBOY;N|q}?-5vXV1Zsx(z<2=gQ>{O!Wm z7TmI6ZGwWW*fKY6(aVOfW}Yv6CG+#V6Lr@(?+P$a3Y1g9_*itupzMXtHqW33@|T|( zdiV18_s2fA=-ZatGSAKW^xV5+;~>kw&b>He$6x0~4cPPee8FFVx`-&H8wicn4rlJCCZlIX)5F4}CH|L3jP6nXLjxEk=o2S_ z<q)??2TSc;T6XKCm=#IahfDA$pk+_h_z)F=0gvLv&gSYWHk#Ct+ny|lkf2Y3 zzySPP_iU(Fs00ExG$gs2<&BPpVA6x%#o~ut8PQXaMiI_k-pmpVF!)_7et`Qg4p8*w zm0)N{ R>M!XpIUFgG+)bg|{{x+|A&vk5 literal 0 HcmV?d00001 diff --git a/test/resource/fms/fms_provider_ability_bundle/FormSystemTestServiceB.hap b/test/resource/fms/fms_provider_ability_bundle/FormSystemTestServiceB.hap new file mode 100644 index 0000000000000000000000000000000000000000..dbc971a82f5e1532619d4b37435625268a844bdf GIT binary patch literal 420448 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�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