From c74f4ceb46a06378ead55be7a1e4d961e94f3b69 Mon Sep 17 00:00:00 2001 From: Wang Luyao Date: Wed, 3 Sep 2025 17:40:59 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BB=8E=E7=83=AD=E8=9E=8D=E5=90=88=E6=A1=A3?= =?UTF-8?q?=E4=BD=8D=E5=88=87=E6=8D=A2=E8=87=B3=E6=B8=A9=E5=BA=A6=E6=A1=A3?= =?UTF-8?q?=E4=BD=8D=20=E6=8C=91=E5=8D=956.0.0=20release?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Wang Luyao --- bundle.json | 3 +- distributedfile.gni | 6 +- .../src/sync_rule/system_load.cpp | 67 +-- .../native/cloud_file_kit_inner/BUILD.gn | 8 +- .../native/cloud_file_kit_inner/system_load.h | 60 ++- services/cloudsyncservice/BUILD.gn | 15 +- .../cycle_task/tasks/optimize_cache_task.cpp | 2 +- .../tasks/optimize_storage_task.cpp | 2 +- .../cycle_task/tasks/periodic_check_task.cpp | 2 +- .../src/ipc/cloud_sync_service.cpp | 6 +- test/unittests/clouddisk_database/BUILD.gn | 8 +- .../cloudsync_sa/cycle_task/BUILD.gn | 8 +- .../cloud_sync_service_cycle_task_test.cpp | 81 +++- test/unittests/cloudsync_sa/ipc/BUILD.gn | 8 +- .../unittests/cloudsync_sa/sync_rule/BUILD.gn | 49 ++- .../sync_rule/system_load_test.cpp | 389 +++++++++++++----- .../unittests/cloudsync_sa/transport/BUILD.gn | 16 +- 17 files changed, 534 insertions(+), 196 deletions(-) diff --git a/bundle.json b/bundle.json index f4c7debe9..5460115ae 100644 --- a/bundle.json +++ b/bundle.json @@ -35,6 +35,7 @@ "access_token", "app_file_service", "battery_manager", + "bundle_framework", "c_utils", "cJSON", "common_event_service", @@ -67,9 +68,9 @@ "storage_service", "samgr", "selinux_adapter", + "thermal_manager", "os_account", "power_manager", - "resource_schedule_service", "libfuse", "zlib" ], diff --git a/distributedfile.gni b/distributedfile.gni index d34f5d54b..2e8d8a0c1 100644 --- a/distributedfile.gni +++ b/distributedfile.gni @@ -40,10 +40,10 @@ declare_args() { dfs_service_feature_enable_dist_file_daemon = true if (defined(global_parts_info) && - defined(global_parts_info.resourceschedule_resource_schedule_service)) { - cloudsync_service_resource_schedule = true + defined(global_parts_info.powermgr_thermal_manager)) { + support_thermal_manager = true } else { - cloudsync_service_resource_schedule = false + support_thermal_manager = false } if (defined(global_parts_info) && diff --git a/frameworks/native/cloud_file_kit_inner/src/sync_rule/system_load.cpp b/frameworks/native/cloud_file_kit_inner/src/sync_rule/system_load.cpp index 142c166e6..e3bf02220 100644 --- a/frameworks/native/cloud_file_kit_inner/src/sync_rule/system_load.cpp +++ b/frameworks/native/cloud_file_kit_inner/src/sync_rule/system_load.cpp @@ -19,34 +19,46 @@ #include "parameters.h" #include "task_state_manager.h" #include "utils_log.h" -#include "res_sched_client.h" +#ifdef support_thermal_manager +#include "thermal_mgr_client.h" +#endif namespace OHOS::FileManagement::CloudSync { - -void SystemLoadListener::SetDataSycner(std::shared_ptr dataSyncManager) +#ifdef support_thermal_manager +std::shared_ptr SystemLoadStatus::thermalListener_ = + std::make_shared(); +std::shared_ptr SystemLoadStatus::thermalEvent_ = std::make_shared(); +std::atomic SystemLoadStatus::levelStatus_ = PowerMgr::ThermalLevel::NORMAL; +void SystemLoadEvent::SetDataSyncer(std::shared_ptr dataSyncManager) { dataSyncManager_ = dataSyncManager; } void SystemLoadStatus::RegisterSystemloadCallback(std::shared_ptr dataSyncManager) { - sptr loadListener = new (std::nothrow) SystemLoadListener(); - if (loadListener == nullptr) { + if (thermalEvent_ == nullptr) { + LOGE("thermalEvent_ is nullptr"); + return; + } + thermalEvent_->SetDataSyncer(dataSyncManager); + int32_t ret = thermalListener_->SubscribeLevelEvent(thermalEvent_); + if (ret != E_OK) { + LOGE("SubscribeLevelEvent failed, ret:%{public}d", ret); return; } - loadListener->SetDataSycner(dataSyncManager); - ResourceSchedule::ResSchedClient::GetInstance().RegisterSystemloadNotifier(loadListener); } -void SystemLoadListener::OnSystemloadLevel(int32_t level) +void SystemLoadEvent::OnThermalLevelResult(const PowerMgr::ThermalLevel &level) { + LOGD("thermal level change, old is:%{public}d, new is %{public}d", + static_cast(SystemLoadStatus::Getload()), static_cast(level)); SystemLoadStatus::Setload(level); - if (level >= SYSTEMLOADLEVEL_HOT) { - LOGI("OnSystemloadLevel over warm"); + if (level >= PowerMgr::ThermalLevel::HOT) { + LOGI("thermal over warm"); } else if (dataSyncManager_) { std::string systemLoadSync = system::GetParameter(TEMPERATURE_SYSPARAM_SYNC, ""); std::string systemLoadThumb = system::GetParameter(TEMPERATURE_SYSPARAM_THUMB, ""); - LOGI("OnSystemloadLevel is normal, level:%{public}d", level); + LOGI("thermal under warm, level:%{public}d", level); if (systemLoadSync == "true") { LOGI("SetParameter TEMPERATURE_SYSPARAM_SYNC false"); system::SetParameter(TEMPERATURE_SYSPARAM_SYNC, "false"); @@ -54,9 +66,9 @@ void SystemLoadListener::OnSystemloadLevel(int32_t level) dataSyncManager_->TriggerRecoverySync(SyncTriggerType::SYSTEM_LOAD_TRIGGER); } if (systemLoadThumb == "true") { - if (BatteryStatus::IsCharging() && level > SYSTEMLOADLEVEL_WARM) { + if (BatteryStatus::IsCharging() && level > PowerMgr::ThermalLevel::WARM) { return; - } else if (!BatteryStatus::IsCharging() && level > SYSTEMLOADLEVEL_NORMAL) { + } else if (!BatteryStatus::IsCharging() && level > PowerMgr::ThermalLevel::NORMAL) { return; } LOGI("SetParameter TEMPERATURE_SYSPARAM_THUMB false"); @@ -69,33 +81,31 @@ void SystemLoadListener::OnSystemloadLevel(int32_t level) void SystemLoadStatus::GetSystemloadLevel() { - loadstatus_ = ResourceSchedule::ResSchedClient::GetInstance().GetSystemloadLevel(); - LOGI("GetSystemloadLevel finish, loadstatus:%{public}d", loadstatus_); + Setload(PowerMgr::ThermalMgrClient::GetInstance().GetThermalLevel()); + LOGI("GetThermalLevel finish, load level is:%{public}d", static_cast(Getload())); } -void SystemLoadStatus::Setload(int32_t load) +void SystemLoadStatus::Setload(const PowerMgr::ThermalLevel &level) { - loadstatus_ = load; + levelStatus_.store(level); } -void SystemLoadStatus::InitSystemload(std::shared_ptr dataSyncManager) +PowerMgr::ThermalLevel SystemLoadStatus::Getload() { - GetSystemloadLevel(); - RegisterSystemloadCallback(dataSyncManager); + return levelStatus_.load(); } -bool SystemLoadStatus::IsLoadStatusUnderNormal() +void SystemLoadStatus::InitSystemload(std::shared_ptr dataSyncManager) { - if (loadstatus_ > SYSTEMLOADLEVEL_NORMAL) { - LOGI("system load is over normal"); - return false; - } - return true; + GetSystemloadLevel(); + RegisterSystemloadCallback(dataSyncManager); } +#endif -bool SystemLoadStatus::IsLoadStatusUnderHot(STOPPED_TYPE process, int32_t level) +bool SystemLoadStatus::IsSystemLoadAllowed(STOPPED_TYPE process, const PowerMgr::ThermalLevel &level) { - if (loadstatus_ > level) { +#ifdef support_thermal_manager + if (Getload() > level) { if (process == STOPPED_IN_THUMB) { LOGI("SetParameter TEMPERATURE_SYSPARAM_THUMB true"); system::SetParameter(TEMPERATURE_SYSPARAM_THUMB, "true"); @@ -105,6 +115,7 @@ bool SystemLoadStatus::IsLoadStatusUnderHot(STOPPED_TYPE process, int32_t level) } return false; } +#endif return true; } } \ No newline at end of file diff --git a/interfaces/inner_api/native/cloud_file_kit_inner/BUILD.gn b/interfaces/inner_api/native/cloud_file_kit_inner/BUILD.gn index 581e69e77..e18ecffa2 100644 --- a/interfaces/inner_api/native/cloud_file_kit_inner/BUILD.gn +++ b/interfaces/inner_api/native/cloud_file_kit_inner/BUILD.gn @@ -121,9 +121,11 @@ ohos_shared_library("cloudfile_kit") { defines += [ "SUPPORT_POWER" ] } - if (cloudsync_service_resource_schedule) { - external_deps += [ "resource_schedule_service:ressched_client" ] - defines += [ "CLOUDSYNC_SERVICE_RESOURCE_SCHEDULE" ] + if (support_thermal_manager) { + external_deps += [ "bundle_framework:appexecfwk_base" ] + external_deps += [ "thermal_manager:thermalmgr_listener" ] + external_deps += [ "thermal_manager:thermalsrv_client" ] + defines += [ "support_thermal_manager" ] } deps = [ "${utils_path}:libdistributedfileutils" ] diff --git a/interfaces/inner_api/native/cloud_file_kit_inner/system_load.h b/interfaces/inner_api/native/cloud_file_kit_inner/system_load.h index 26c8f67a0..0d658fc2d 100644 --- a/interfaces/inner_api/native/cloud_file_kit_inner/system_load.h +++ b/interfaces/inner_api/native/cloud_file_kit_inner/system_load.h @@ -18,44 +18,62 @@ #include "data_sync_manager.h" #include -#include "res_sched_systemload_notifier_client.h" -#include "res_type.h" #include "sync_state_manager.h" +#include +#ifdef support_thermal_manager +#include "thermal_mgr_listener.h" +#else +namespace OHOS::PowerMgr { +enum class ThermalLevel : int32_t { + COOL, + NORMAL, + WARM, + HOT, + OVERHEATED, + WARNING, + EMERGENCY, + ESCAPE, +}; +} +#endif namespace OHOS::FileManagement::CloudSync { -constexpr int32_t SYSTEMLOADLEVEL_HOT = ResourceSchedule::ResType::SystemloadLevel::HIGH; -constexpr int32_t SYSTEMLOADLEVEL_WARM = ResourceSchedule::ResType::SystemloadLevel::MEDIUM; -constexpr int32_t SYSTEMLOADLEVEL_NORMAL = ResourceSchedule::ResType::SystemloadLevel::NORMAL; -const std::string TEMPERATURE_SYSPARAM_SYNC = "persist.kernel.cloudsync.temperature_abnormal_sync"; -const std::string TEMPERATURE_SYSPARAM_THUMB = "persist.kernel.cloudsync.temperature_abnormal_thumb"; - enum STOPPED_TYPE { STOPPED_IN_SYNC = 0, STOPPED_IN_THUMB = 1, STOPPED_IN_OTHER = 2, }; +#ifdef support_thermal_manager +const std::string TEMPERATURE_SYSPARAM_SYNC = "persist.kernel.cloudsync.temperature_abnormal_sync"; +const std::string TEMPERATURE_SYSPARAM_THUMB = "persist.kernel.cloudsync.temperature_abnormal_thumb"; + +class SystemLoadEvent : public PowerMgr::ThermalMgrListener::ThermalLevelEvent { +public: + SystemLoadEvent() = default; + void OnThermalLevelResult(const PowerMgr::ThermalLevel &level) override; + void SetDataSyncer(std::shared_ptr dataSyncManager); +private: + std::shared_ptr dataSyncManager_ = nullptr; +}; +#endif class SystemLoadStatus { public: SystemLoadStatus() = default; virtual ~SystemLoadStatus() = default; + static bool IsSystemLoadAllowed(STOPPED_TYPE process = STOPPED_IN_OTHER, + const PowerMgr::ThermalLevel &level = PowerMgr::ThermalLevel::HOT); + static void Setload(const PowerMgr::ThermalLevel &level); + static PowerMgr::ThermalLevel Getload(); +#ifdef support_thermal_manager static void RegisterSystemloadCallback(std::shared_ptr dataSyncManager); static void GetSystemloadLevel(); - static bool IsLoadStatusUnderHot(STOPPED_TYPE process = STOPPED_IN_OTHER, int32_t level = SYSTEMLOADLEVEL_HOT); - static bool IsLoadStatusUnderNormal(); static void InitSystemload(std::shared_ptr dataSyncManager); - static void Setload(int32_t load); - static inline int32_t loadstatus_ = 0; -}; - -class SystemLoadListener : public ResourceSchedule::ResSchedSystemloadNotifierClient { -public: - SystemLoadListener() = default; - void OnSystemloadLevel(int32_t level) override; - void SetDataSycner(std::shared_ptr dataSyncManager); private: - std::shared_ptr dataSyncManager_ = nullptr; + static std::atomic levelStatus_; + static std::shared_ptr thermalListener_; + static std::shared_ptr thermalEvent_; +#endif }; } // OHOS - #endif // OHOS_FILEMGMT_CLOUD_SYNC_SYSTEM_LOAD_H \ No newline at end of file diff --git a/services/cloudsyncservice/BUILD.gn b/services/cloudsyncservice/BUILD.gn index 947485706..1c0bdfd01 100644 --- a/services/cloudsyncservice/BUILD.gn +++ b/services/cloudsyncservice/BUILD.gn @@ -196,8 +196,11 @@ ohos_shared_library("cloudsync_sa") { defines += [ "HICOLLIE_ENABLE" ] } - if (cloudsync_service_resource_schedule) { - external_deps += [ "resource_schedule_service:ressched_client" ] + if (support_thermal_manager) { + external_deps += [ "bundle_framework:appexecfwk_base" ] + external_deps += [ "thermal_manager:thermalmgr_listener" ] + external_deps += [ "thermal_manager:thermalsrv_client" ] + defines += [ "support_thermal_manager" ] } use_exceptions = true @@ -312,9 +315,11 @@ ohos_static_library("cloudsync_sa_static") { deps += [ "${distributedfile_path}/adapter/cloud_adapter_example:cloud_adapter" ] - if (cloudsync_service_resource_schedule) { - external_deps += [ "resource_schedule_service:ressched_client" ] - defines += [ "CLOUDSYNC_SERVICE_RESOURCE_SCHEDULE" ] + if (support_thermal_manager) { + external_deps += [ "bundle_framework:appexecfwk_base" ] + external_deps += [ "thermal_manager:thermalmgr_listener" ] + external_deps += [ "thermal_manager:thermalsrv_client" ] + defines += [ "support_thermal_manager" ] } if (cloudsync_service_power) { diff --git a/services/cloudsyncservice/src/cycle_task/tasks/optimize_cache_task.cpp b/services/cloudsyncservice/src/cycle_task/tasks/optimize_cache_task.cpp index 5b846109c..98bcc6794 100644 --- a/services/cloudsyncservice/src/cycle_task/tasks/optimize_cache_task.cpp +++ b/services/cloudsyncservice/src/cycle_task/tasks/optimize_cache_task.cpp @@ -33,7 +33,7 @@ OptimizeCacheTask::OptimizeCacheTask(std::shared_ptr int32_t OptimizeCacheTask::RunTaskForBundle(int32_t userId, std::string bundleName) { - if (!SystemLoadStatus::IsLoadStatusUnderHot()) { + if (!SystemLoadStatus::IsSystemLoadAllowed()) { LOGE("OptimizeCacheTask::RunTaskForBundle system load is over hot"); return E_STOP; } diff --git a/services/cloudsyncservice/src/cycle_task/tasks/optimize_storage_task.cpp b/services/cloudsyncservice/src/cycle_task/tasks/optimize_storage_task.cpp index 420a1b9ea..b7c44975f 100644 --- a/services/cloudsyncservice/src/cycle_task/tasks/optimize_storage_task.cpp +++ b/services/cloudsyncservice/src/cycle_task/tasks/optimize_storage_task.cpp @@ -29,7 +29,7 @@ OptimizeStorageTask::OptimizeStorageTask(std::shared_ptr int32_t PeriodicCheckTask::RunTaskForBundle(int32_t userId, std::string bundleName) { if (ScreenStatus::IsScreenOn() || !BatteryStatus::IsCharging() - || !SystemLoadStatus::IsLoadStatusUnderHot()) { + || !SystemLoadStatus::IsSystemLoadAllowed()) { LOGI("PeriodicCheckTask::RunTaskForBundle isScreenOn or not charging"); return E_STOP; } diff --git a/services/cloudsyncservice/src/ipc/cloud_sync_service.cpp b/services/cloudsyncservice/src/ipc/cloud_sync_service.cpp index 8920d67ec..a353e07ce 100644 --- a/services/cloudsyncservice/src/ipc/cloud_sync_service.cpp +++ b/services/cloudsyncservice/src/ipc/cloud_sync_service.cpp @@ -182,7 +182,7 @@ void CloudSyncService::OnStart(const SystemAbilityOnDemandReason& startReason) PublishSA(); AddSystemAbilityListener(COMMON_EVENT_SERVICE_ID); AddSystemAbilityListener(SOFTBUS_SERVER_SA_ID); - AddSystemAbilityListener(RES_SCHED_SYS_ABILITY_ID); + AddSystemAbilityListener(POWER_MANAGER_THERMAL_SERVICE_ID); AddSystemAbilityListener(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID); AddSystemAbilityListener(MEMORY_MANAGER_SA_ID); } catch (const exception &e) { @@ -307,8 +307,10 @@ void CloudSyncService::OnAddSystemAbility(int32_t systemAbilityId, const std::st userStatusListener_->AddObserver(sessionManager); fileTransferManager_ = make_shared(sessionManager); fileTransferManager_->Init(); - } else if (systemAbilityId == RES_SCHED_SYS_ABILITY_ID) { + } else if (systemAbilityId == POWER_MANAGER_THERMAL_SERVICE_ID) { +#ifdef support_thermal_manager SystemLoadStatus::InitSystemload(dataSyncManager_); +#endif } else if (systemAbilityId == COMM_NET_CONN_MANAGER_SYS_ABILITY_ID) { NetworkStatus::InitNetwork(dataSyncManager_); } else if (systemAbilityId == MEMORY_MANAGER_SA_ID) { diff --git a/test/unittests/clouddisk_database/BUILD.gn b/test/unittests/clouddisk_database/BUILD.gn index 74bad1e92..02234c5cf 100644 --- a/test/unittests/clouddisk_database/BUILD.gn +++ b/test/unittests/clouddisk_database/BUILD.gn @@ -193,9 +193,11 @@ ohos_unittest("clouddisk_rdbstore_test") { defines += [ "HICOLLIE_ENABLE" ] } - if (cloudsync_service_resource_schedule) { - external_deps += [ "resource_schedule_service:ressched_client" ] - defines += [ "CLOUDSYNC_SERVICE_RESOURCE_SCHEDULE" ] + if (support_thermal_manager) { + external_deps += [ "bundle_framework:appexecfwk_base" ] + external_deps += [ "thermal_manager:thermalmgr_listener" ] + external_deps += [ "thermal_manager:thermalsrv_client" ] + defines += [ "support_thermal_manager" ] } use_exceptions = true diff --git a/test/unittests/cloudsync_sa/cycle_task/BUILD.gn b/test/unittests/cloudsync_sa/cycle_task/BUILD.gn index ec5c49e94..3d7f697ef 100644 --- a/test/unittests/cloudsync_sa/cycle_task/BUILD.gn +++ b/test/unittests/cloudsync_sa/cycle_task/BUILD.gn @@ -82,9 +82,11 @@ ohos_unittest("cloud_sync_service_cycle_task_test") { external_deps += [ "hicollie:libhicollie" ] defines += [ "HICOLLIE_ENABLE" ] } - if (cloudsync_service_resource_schedule) { - external_deps += [ "resource_schedule_service:ressched_client" ] - defines += [ "CLOUDSYNC_SERVICE_RESOURCE_SCHEDULE" ] + if (support_thermal_manager) { + external_deps += [ "bundle_framework:appexecfwk_base" ] + external_deps += [ "thermal_manager:thermalmgr_listener" ] + external_deps += [ "thermal_manager:thermalsrv_client" ] + defines += [ "support_thermal_manager" ] } use_exceptions = true } diff --git a/test/unittests/cloudsync_sa/cycle_task/cloud_sync_service_cycle_task_test.cpp b/test/unittests/cloudsync_sa/cycle_task/cloud_sync_service_cycle_task_test.cpp index 9057432d5..d3c80028d 100644 --- a/test/unittests/cloudsync_sa/cycle_task/cloud_sync_service_cycle_task_test.cpp +++ b/test/unittests/cloudsync_sa/cycle_task/cloud_sync_service_cycle_task_test.cpp @@ -19,6 +19,7 @@ #include "dfs_error.h" #include "cycle_task.h" #include "cycle_task_runner.h" +#include "system_load.h" #include "tasks/database_backup_task.h" #include "tasks/optimize_cache_task.h" #include "tasks/optimize_storage_task.h" @@ -120,6 +121,7 @@ HWTEST_F(CloudSyncServiceCycleTaskTest, RunTaskForBundleTest002, TestSize.Level1 string bundleName = "com.ohos.photos"; int32_t userId = 100; EXPECT_NE(g_dataSyncManagerPtr_, nullptr); + SystemLoadStatus::Setload(PowerMgr::ThermalLevel::NORMAL); shared_ptr task = make_shared(g_dataSyncManagerPtr_); int32_t ret = task->RunTaskForBundle(userId, bundleName); EXPECT_NE(ret, 0); @@ -143,6 +145,7 @@ HWTEST_F(CloudSyncServiceCycleTaskTest, RunTaskForBundleTest003, TestSize.Level1 string bundleName = "com.ohos.photos"; int32_t userId = 100; EXPECT_NE(g_dataSyncManagerPtr_, nullptr); + SystemLoadStatus::Setload(PowerMgr::ThermalLevel::NORMAL); shared_ptr task = make_shared(g_dataSyncManagerPtr_); int32_t ret = task->RunTaskForBundle(userId, bundleName); EXPECT_NE(ret, 0); @@ -273,9 +276,9 @@ HWTEST_F(CloudSyncServiceCycleTaskTest, RunTaskForBundleTest006, TestSize.Level1 string bundleName = "com.ohos.photos"; int32_t userId = 100; EXPECT_NE(g_dataSyncManagerPtr_, nullptr); + SystemLoadStatus::Setload(PowerMgr::ThermalLevel::NORMAL); shared_ptr task = make_shared(g_dataSyncManagerPtr_); int32_t ret = task->RunTaskForBundle(userId, bundleName); - EXPECT_EQ(ret, 0); } catch (...) { EXPECT_TRUE(false); @@ -298,6 +301,7 @@ HWTEST_F(CloudSyncServiceCycleTaskTest, RunTaskForBundleTest007, TestSize.Level1 int32_t userId = 100; CloudFile::CloudFileKit::instance_ = ability.get(); EXPECT_NE(g_dataSyncManagerPtr_, nullptr); + SystemLoadStatus::Setload(PowerMgr::ThermalLevel::NORMAL); shared_ptr task = make_shared(g_dataSyncManagerPtr_); int32_t ret = task->RunTaskForBundle(userId, bundleName); @@ -358,6 +362,81 @@ HWTEST_F(CloudSyncServiceCycleTaskTest, RunTaskForBundleTest009, TestSize.Level1 GTEST_LOG_(INFO) << "RunTaskForBundleTest009 end"; } +/** + * @tc.name: RunTaskForBundleTest010 + * @tc.desc: 温控后不触发核查任务 + * @tc.type: FUNC + * @tc.require: IB3SWZ + */ +HWTEST_F(CloudSyncServiceCycleTaskTest, RunTaskForBundleTest010, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "RunTaskForBundleTest010 start"; + try { + string bundleName = "com.ohos.photos"; + int32_t userId = 100; + EXPECT_NE(g_dataSyncManagerPtr_, nullptr); + SystemLoadStatus::Setload(PowerMgr::ThermalLevel::OVERHEATED); + shared_ptr task = make_shared(g_dataSyncManagerPtr_); + int32_t ret = task->RunTaskForBundle(userId, bundleName); + EXPECT_EQ(ret, E_STOP); + SystemLoadStatus::Setload(PowerMgr::ThermalLevel::NORMAL); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "RunTaskForBundleTest010 FAILED"; + } + GTEST_LOG_(INFO) << "RunTaskForBundleTest010 end"; +} + +/** + * @tc.name: RunTaskForBundleTest011 + * @tc.desc: 温控后不触发老化任务 + * @tc.type: FUNC + * @tc.require: IB3SWZ + */ +HWTEST_F(CloudSyncServiceCycleTaskTest, RunTaskForBundleTest011, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "RunTaskForBundleTest011 start"; + try { + string bundleName = "com.ohos.photos"; + int32_t userId = 100; + EXPECT_NE(g_dataSyncManagerPtr_, nullptr); + SystemLoadStatus::Setload(PowerMgr::ThermalLevel::OVERHEATED); + shared_ptr task = make_shared(g_dataSyncManagerPtr_); + int32_t ret = task->RunTaskForBundle(userId, bundleName); + EXPECT_EQ(ret, E_STOP); + SystemLoadStatus::Setload(PowerMgr::ThermalLevel::NORMAL); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "RunTaskForBundleTest011 FAILED"; + } + GTEST_LOG_(INFO) << "RunTaskForBundleTest011 end"; +} + +/** + * @tc.name: RunTaskForBundleTest012 + * @tc.desc: 温控后不触发清理任务 + * @tc.type: FUNC + * @tc.require: IB3SWZ + */ +HWTEST_F(CloudSyncServiceCycleTaskTest, RunTaskForBundleTest012, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "RunTaskForBundleTest012 start"; + try { + string bundleName = "com.ohos.photos"; + int32_t userId = 100; + EXPECT_NE(g_dataSyncManagerPtr_, nullptr); + SystemLoadStatus::Setload(PowerMgr::ThermalLevel::OVERHEATED); + shared_ptr task = make_shared(g_dataSyncManagerPtr_); + int32_t ret = task->RunTaskForBundle(userId, bundleName); + EXPECT_EQ(ret, E_STOP); + SystemLoadStatus::Setload(PowerMgr::ThermalLevel::NORMAL); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "RunTaskForBundleTest012 FAILED"; + } + GTEST_LOG_(INFO) << "RunTaskForBundleTest012 end"; +} + /* * @tc.name: CycleTaskRunnerTest * @tc.desc: Verify the CycleTaskRunner function. diff --git a/test/unittests/cloudsync_sa/ipc/BUILD.gn b/test/unittests/cloudsync_sa/ipc/BUILD.gn index bc6c969ad..5c3798cd7 100644 --- a/test/unittests/cloudsync_sa/ipc/BUILD.gn +++ b/test/unittests/cloudsync_sa/ipc/BUILD.gn @@ -119,9 +119,11 @@ ohos_unittest("cloud_sync_service_test") { external_deps += [ "hicollie:libhicollie" ] defines += [ "HICOLLIE_ENABLE" ] } - if (cloudsync_service_resource_schedule) { - external_deps += [ "resource_schedule_service:ressched_client" ] - defines += [ "CLOUDSYNC_SERVICE_RESOURCE_SCHEDULE" ] + if (support_thermal_manager) { + external_deps += [ "bundle_framework:appexecfwk_base" ] + external_deps += [ "thermal_manager:thermalmgr_listener" ] + external_deps += [ "thermal_manager:thermalsrv_client" ] + defines += [ "support_thermal_manager" ] } if (cloudsync_service_power) { diff --git a/test/unittests/cloudsync_sa/sync_rule/BUILD.gn b/test/unittests/cloudsync_sa/sync_rule/BUILD.gn index 4f252ad2f..b3b3e56cd 100644 --- a/test/unittests/cloudsync_sa/sync_rule/BUILD.gn +++ b/test/unittests/cloudsync_sa/sync_rule/BUILD.gn @@ -71,9 +71,11 @@ ohos_unittest("battery_status_listener_test") { "LOG_TAG=\"CLOUD_SYNC_TEST\"", ] - if (cloudsync_service_resource_schedule) { - external_deps += [ "resource_schedule_service:ressched_client" ] - defines += [ "CLOUDSYNC_SERVICE_RESOURCE_SCHEDULE" ] + if (support_thermal_manager) { + external_deps += [ "bundle_framework:appexecfwk_base" ] + external_deps += [ "thermal_manager:thermalmgr_listener" ] + external_deps += [ "thermal_manager:thermalsrv_client" ] + defines += [ "support_thermal_manager" ] } if (cloudsync_service_power) { @@ -173,9 +175,11 @@ ohos_unittest("network_status_test") { ] defines = [ "private=public" ] - if (cloudsync_service_resource_schedule) { - external_deps += [ "resource_schedule_service:ressched_client" ] - defines += [ "CLOUDSYNC_SERVICE_RESOURCE_SCHEDULE" ] + if (support_thermal_manager) { + external_deps += [ "bundle_framework:appexecfwk_base" ] + external_deps += [ "thermal_manager:thermalmgr_listener" ] + external_deps += [ "thermal_manager:thermalsrv_client" ] + defines += [ "support_thermal_manager" ] } use_exceptions = true } @@ -378,11 +382,18 @@ ohos_unittest("system_load_test") { "ipc:ipc_core", "netmanager_base:net_conn_manager_if", "relational_store:native_rdb", - "resource_schedule_service:ressched_client", "samgr:samgr_proxy", ] defines = [ "private=public" ] + + if (support_thermal_manager) { + external_deps += [ "bundle_framework:appexecfwk_base" ] + external_deps += [ "thermal_manager:thermalmgr_listener" ] + external_deps += [ "thermal_manager:thermalsrv_client" ] + defines += [ "support_thermal_manager" ] + } + use_exceptions = true } @@ -437,9 +448,11 @@ ohos_unittest("screen_status_listener_test") { "LOG_DOMAIN=0xD004310", "LOG_TAG=\"CLOUD_SYNC_TEST\"", ] - if (cloudsync_service_resource_schedule) { - external_deps += [ "resource_schedule_service:ressched_client" ] - defines += [ "CLOUDSYNC_SERVICE_RESOURCE_SCHEDULE" ] + if (support_thermal_manager) { + external_deps += [ "bundle_framework:appexecfwk_base" ] + external_deps += [ "thermal_manager:thermalmgr_listener" ] + external_deps += [ "thermal_manager:thermalsrv_client" ] + defines += [ "support_thermal_manager" ] } use_exceptions = true } @@ -498,9 +511,11 @@ ohos_unittest("user_status_listener_test") { "LOG_DOMAIN=0xD004310", "LOG_TAG=\"CLOUD_SYNC_TEST\"", ] - if (cloudsync_service_resource_schedule) { - external_deps += [ "resource_schedule_service:ressched_client" ] - defines += [ "CLOUDSYNC_SERVICE_RESOURCE_SCHEDULE" ] + if (support_thermal_manager) { + external_deps += [ "bundle_framework:appexecfwk_base" ] + external_deps += [ "thermal_manager:thermalmgr_listener" ] + external_deps += [ "thermal_manager:thermalsrv_client" ] + defines += [ "support_thermal_manager" ] } use_exceptions = true } @@ -557,9 +572,11 @@ ohos_unittest("package_status_listener_test") { "LOG_DOMAIN=0xD004310", "LOG_TAG=\"CLOUD_SYNC_TEST\"", ] - if (cloudsync_service_resource_schedule) { - external_deps += [ "resource_schedule_service:ressched_client" ] - defines += [ "CLOUDSYNC_SERVICE_RESOURCE_SCHEDULE" ] + if (support_thermal_manager) { + external_deps += [ "bundle_framework:appexecfwk_base" ] + external_deps += [ "thermal_manager:thermalmgr_listener" ] + external_deps += [ "thermal_manager:thermalsrv_client" ] + defines += [ "support_thermal_manager" ] } use_exceptions = true } diff --git a/test/unittests/cloudsync_sa/sync_rule/system_load_test.cpp b/test/unittests/cloudsync_sa/sync_rule/system_load_test.cpp index c09d5489e..63166792d 100644 --- a/test/unittests/cloudsync_sa/sync_rule/system_load_test.cpp +++ b/test/unittests/cloudsync_sa/sync_rule/system_load_test.cpp @@ -16,11 +16,11 @@ #include #include +#include "battery_status.h" #include "system_load.h" #include "dfs_error.h" #include "parameters.h" #include "utils_log.h" -#include "res_sched_client.h" #include "task_state_manager.h" namespace OHOS::FileManagement::CloudSync::Test { @@ -34,8 +34,10 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - shared_ptr SystemLoadStatus_ = nullptr; - shared_ptr SystemLoadListener_ = nullptr; +#ifdef support_thermal_manager + shared_ptr systemLoadStatus_ = nullptr; + shared_ptr systemLoadEvent_ = nullptr; +#endif }; void SytemLoadTest::SetUpTestCase(void) @@ -50,233 +52,424 @@ void SytemLoadTest::TearDownTestCase(void) void SytemLoadTest::SetUp(void) { +#ifdef support_thermal_manager GTEST_LOG_(INFO) << "SetUp"; - SystemLoadStatus_ = make_shared(); - SystemLoadListener_ = make_shared(); + systemLoadStatus_ = make_shared(); + systemLoadEvent_ = make_shared(); + systemLoadStatus_->thermalEvent_ = systemLoadEvent_; +#endif } void SytemLoadTest::TearDown(void) { +#ifdef support_thermal_manager GTEST_LOG_(INFO) << "TearDown"; TaskStateManager::GetInstance().CancelUnloadTask(); - SystemLoadStatus_ = nullptr; - SystemLoadListener_ = nullptr; + systemLoadStatus_ = nullptr; + systemLoadEvent_ = nullptr; +#endif } +#ifdef support_thermal_manager /** - * @tc.name: RegisterSystemloadCallbackTest + * @tc.name: RegisterSystemloadCallbackTest001 * @tc.desc: Verify the RegisterSystemloadCallback function * @tc.type: FUNC * @tc.require: I6JPKG */ -HWTEST_F(SytemLoadTest, RegisterSystemloadCallbackTest, TestSize.Level1) +HWTEST_F(SytemLoadTest, RegisterSystemloadCallbackTest001, TestSize.Level1) { GTEST_LOG_(INFO) << "RegisterSystemloadCallbackTest Start"; try { std::shared_ptr dataSyncManager; - SystemLoadStatus_->RegisterSystemloadCallback(dataSyncManager); + systemLoadStatus_->RegisterSystemloadCallback(dataSyncManager); } catch (...) { EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "RegisterSystemloadCallbackTest FAILED"; + GTEST_LOG_(INFO) << "RegisterSystemloadCallbackTest001 FAILED"; } - GTEST_LOG_(INFO) << "RegisterSystemloadCallbackTest End"; + GTEST_LOG_(INFO) << "RegisterSystemloadCallbackTest001 End"; } /** - * @tc.name: OnSystemloadLevelTest001 - * @tc.desc: Verify the OnSystemloadLevel function + * @tc.name: RegisterSystemloadCallbackTest002 + * @tc.desc: Verify the RegisterSystemloadCallback function + * @tc.type: FUNC + * @tc.require: I6JPKG + */ +HWTEST_F(SytemLoadTest, RegisterSystemloadCallbackTest002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "RegisterSystemloadCallbackTest002 Start"; + try { + systemLoadStatus_->thermalEvent_ = nullptr; + std::shared_ptr dataSyncManager; + systemLoadStatus_->RegisterSystemloadCallback(dataSyncManager); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "RegisterSystemloadCallbackTest002 FAILED"; + } + GTEST_LOG_(INFO) << "RegisterSystemloadCallbackTest002 End"; +} + +/** + * @tc.name: OnThermalLevelResultTest001 + * @tc.desc: Verify the OnThermalLevelResult function * @tc.type: FUNC * @tc.require: I6JPKG */ -HWTEST_F(SytemLoadTest, OnSystemloadLevelTest001, TestSize.Level1) +HWTEST_F(SytemLoadTest, OnThermalLevelResultTest001, TestSize.Level1) { - GTEST_LOG_(INFO) << "OnSystemloadLevelTest001 Start"; + GTEST_LOG_(INFO) << "OnThermalLevelResultTest001 Start"; try { - int32_t level = 10; - SystemLoadListener_->OnSystemloadLevel(level); + systemLoadEvent_->OnThermalLevelResult(PowerMgr::ThermalLevel::HOT); } catch (...) { EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "OnSystemloadLevelTest001 FAILED"; + GTEST_LOG_(INFO) << "OnThermalLevelResultTest001 FAILED"; } - GTEST_LOG_(INFO) << "OnSystemloadLevelTest001 End"; + GTEST_LOG_(INFO) << "OnThermalLevelResultTest001 End"; } /** - * @tc.name: OnSystemloadLevelTest002 - * @tc.desc: Verify the OnSystemloadLevel function + * @tc.name: OnThermalLevelResultTest002 + * @tc.desc: Verify the OnThermalLevelResult function * @tc.type: FUNC * @tc.require: I6JPKG */ -HWTEST_F(SytemLoadTest, OnSystemloadLevelTest002, TestSize.Level1) +HWTEST_F(SytemLoadTest, OnThermalLevelResultTest002, TestSize.Level1) { - GTEST_LOG_(INFO) << "OnSystemloadLevelTest001 Start"; + GTEST_LOG_(INFO) << "OnThermalLevelResultTest001 Start"; try { - int32_t level = 1; std::shared_ptr dataSyncManager; - SystemLoadListener_->dataSyncManager_ = make_shared(); - SystemLoadListener_->OnSystemloadLevel(level); + systemLoadEvent_->dataSyncManager_ = make_shared(); + systemLoadEvent_->OnThermalLevelResult(PowerMgr::ThermalLevel::NORMAL); } catch (...) { EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "OnSystemloadLevelTest001 FAILED"; + GTEST_LOG_(INFO) << "OnThermalLevelResultTest001 FAILED"; } - GTEST_LOG_(INFO) << "OnSystemloadLevelTest001 End"; + GTEST_LOG_(INFO) << "OnThermalLevelResultTest001 End"; } /** - * @tc.name: OnSystemloadLevelTest003 - * @tc.desc: Verify the OnSystemloadLevel function + * @tc.name: OnThermalLevelResultTest003 + * @tc.desc: Verify the OnThermalLevelResult function * @tc.type: FUNC * @tc.require: I6JPKG */ -HWTEST_F(SytemLoadTest, OnSystemloadLevelTest003, TestSize.Level1) +HWTEST_F(SytemLoadTest, OnThermalLevelResultTest003, TestSize.Level1) { - GTEST_LOG_(INFO) << "OnSystemloadLevelTest003 Start"; + GTEST_LOG_(INFO) << "OnThermalLevelResultTest003 Start"; try { - int32_t level = 1; system::SetParameter(TEMPERATURE_SYSPARAM_SYNC, "true"); auto dataSyncManager = std::make_shared(); - SystemLoadListener_->SetDataSycner(dataSyncManager); - SystemLoadListener_->OnSystemloadLevel(level); + systemLoadEvent_->SetDataSyncer(dataSyncManager); + systemLoadEvent_->OnThermalLevelResult(PowerMgr::ThermalLevel::NORMAL); } catch (...) { EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "OnSystemloadLevelTest003 FAILED"; + GTEST_LOG_(INFO) << "OnThermalLevelResultTest003 FAILED"; } - GTEST_LOG_(INFO) << "OnSystemloadLevelTest003 End"; + GTEST_LOG_(INFO) << "OnThermalLevelResultTest003 End"; } /** - * @tc.name: OnSystemloadLevelTest004 - * @tc.desc: Verify the OnSystemloadLevel function + * @tc.name: OnThermalLevelResultTest004 + * @tc.desc: 充电状态下，NORMAL档位时恢复缩略图下载 * @tc.type: FUNC - * @tc.require: I6JPKG + * @tc.require: ICR23A + */ +HWTEST_F(SytemLoadTest, OnThermalLevelResultTest004, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "OnThermalLevelResultTest004 Start"; + try { + system::SetParameter(TEMPERATURE_SYSPARAM_THUMB, "true"); + BatteryStatus::SetChargingStatus(true); + auto dataSyncManager = std::make_shared(); + systemLoadEvent_->SetDataSyncer(dataSyncManager); + systemLoadEvent_->OnThermalLevelResult(PowerMgr::ThermalLevel::NORMAL); + std::string systemLoadThumb = system::GetParameter(TEMPERATURE_SYSPARAM_THUMB, ""); + EXPECT_EQ("false", systemLoadThumb); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "OnThermalLevelResultTest004 FAILED"; + } + GTEST_LOG_(INFO) << "OnThermalLevelResultTest004 End"; +} + +/** + * @tc.name: OnThermalLevelResultTest005 + * @tc.desc: 充电状态下，warm档位时不恢复缩略图下载 + * @tc.type: FUNC + * @tc.require: ICR23A */ -HWTEST_F(SytemLoadTest, OnSystemloadLevelTest004, TestSize.Level1) +HWTEST_F(SytemLoadTest, OnThermalLevelResultTest005, TestSize.Level1) { - GTEST_LOG_(INFO) << "OnSystemloadLevelTest004 Start"; + GTEST_LOG_(INFO) << "OnThermalLevelResultTest005 Start"; try { - int32_t level = 1; system::SetParameter(TEMPERATURE_SYSPARAM_THUMB, "true"); + BatteryStatus::SetChargingStatus(true); + auto dataSyncManager = std::make_shared(); + systemLoadEvent_->SetDataSyncer(dataSyncManager); + systemLoadEvent_->OnThermalLevelResult(PowerMgr::ThermalLevel::HOT); + std::string systemLoadThumb = system::GetParameter(TEMPERATURE_SYSPARAM_THUMB, ""); + EXPECT_EQ("true", systemLoadThumb); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "OnThermalLevelResultTest005 FAILED"; + } + GTEST_LOG_(INFO) << "OnThermalLevelResultTest005 End"; +} + +/** + * @tc.name: OnThermalLevelResultTest006 + * @tc.desc: 不充电状态下，normal档位时恢复缩略图下载 + * @tc.type: FUNC + * @tc.require: ICR23A + */ +HWTEST_F(SytemLoadTest, OnThermalLevelResultTest006, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "OnThermalLevelResultTest006 Start"; + try { + system::SetParameter(TEMPERATURE_SYSPARAM_THUMB, "true"); + BatteryStatus::SetChargingStatus(false); + auto dataSyncManager = std::make_shared(); + systemLoadEvent_->SetDataSyncer(dataSyncManager); + systemLoadEvent_->OnThermalLevelResult(PowerMgr::ThermalLevel::NORMAL); + std::string systemLoadThumb = system::GetParameter(TEMPERATURE_SYSPARAM_THUMB, ""); + EXPECT_EQ("false", systemLoadThumb); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "OnThermalLevelResultTest006 FAILED"; + } + GTEST_LOG_(INFO) << "OnThermalLevelResultTest006 End"; +} + +/** + * @tc.name: OnThermalLevelResultTest007 + * @tc.desc: 不充电状态下，cool档位时恢复缩略图下载 + * @tc.type: FUNC + * @tc.require: ICR23A + */ +HWTEST_F(SytemLoadTest, OnThermalLevelResultTest007, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "OnThermalLevelResultTest007 Start"; + try { + system::SetParameter(TEMPERATURE_SYSPARAM_THUMB, "true"); + BatteryStatus::SetChargingStatus(false); + auto dataSyncManager = std::make_shared(); + systemLoadEvent_->SetDataSyncer(dataSyncManager); + systemLoadEvent_->OnThermalLevelResult(PowerMgr::ThermalLevel::COOL); + std::string systemLoadThumb = system::GetParameter(TEMPERATURE_SYSPARAM_THUMB, ""); + EXPECT_EQ("false", systemLoadThumb); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "OnThermalLevelResultTest007 FAILED"; + } + GTEST_LOG_(INFO) << "OnThermalLevelResultTest007 End"; +} + +/** + * @tc.name: OnThermalLevelResultTest005 + * @tc.desc: Verify the OnThermalLevelResult function + * @tc.type: FUNC + * @tc.require: I6JPKG + */ +HWTEST_F(SytemLoadTest, OnThermalLevelResultTest0010, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "OnThermalLevelResultTest005 Start"; + try { + system::SetParameter(TEMPERATURE_SYSPARAM_SYNC, "true"); auto dataSyncManager = std::make_shared(); - SystemLoadListener_->SetDataSycner(dataSyncManager); - SystemLoadListener_->OnSystemloadLevel(level); + systemLoadEvent_->SetDataSyncer(dataSyncManager); + system::SetParameter(TEMPERATURE_SYSPARAM_SYNC, "true"); + systemLoadEvent_->OnThermalLevelResult(PowerMgr::ThermalLevel::NORMAL); } catch (...) { EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "OnSystemloadLevelTest004 FAILED"; + GTEST_LOG_(INFO) << "OnThermalLevelResultTest005 FAILED"; } - GTEST_LOG_(INFO) << "OnSystemloadLevelTest004 End"; + GTEST_LOG_(INFO) << "OnThermalLevelResultTest005 End"; } /** - * @tc.name: IsLoadStatusUnderHotTest001 - * @tc.desc: Verify the IsLoadStatusUnderHot function + * @tc.name: IsSystemLoadAllowedTest001 + * @tc.desc: Verify the IsSystemLoadAllowed function * @tc.type: FUNC * @tc.require: I6JPKG */ -HWTEST_F(SytemLoadTest, IsLoadStatusUnderHotTest001, TestSize.Level1) +HWTEST_F(SytemLoadTest, IsSystemLoadAllowedTest001, TestSize.Level1) { - GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 Start"; + GTEST_LOG_(INFO) << "IsSystemLoadAllowedTest001 Start"; try { - SystemLoadStatus_->Setload(10); - bool ret = SystemLoadStatus_->IsLoadStatusUnderHot(); + systemLoadStatus_->Setload(PowerMgr::ThermalLevel::OVERHEATED); + bool ret = systemLoadStatus_->IsSystemLoadAllowed(); EXPECT_EQ(ret, false); } catch (...) { EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 FAILED"; + GTEST_LOG_(INFO) << "IsSystemLoadAllowedTest001 FAILED"; } - GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 End"; + GTEST_LOG_(INFO) << "IsSystemLoadAllowedTest001 End"; } /** - * @tc.name: IsLoadStatusUnderHotTest002 - * @tc.desc: Verify the IsLoadStatusUnderHot function + * @tc.name: IsSystemLoadAllowedTest002 + * @tc.desc: Verify the IsSystemLoadAllowed function * @tc.type: FUNC * @tc.require: I6JPKG */ -HWTEST_F(SytemLoadTest, IsLoadStatusUnderHotTest002, TestSize.Level1) +HWTEST_F(SytemLoadTest, IsSystemLoadAllowedTest002, TestSize.Level1) { - GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 Start"; + GTEST_LOG_(INFO) << "IsSystemLoadAllowedTest002 Start"; try { - SystemLoadStatus_->Setload(10); - bool ret = SystemLoadStatus_->IsLoadStatusUnderHot(); + systemLoadStatus_->Setload(PowerMgr::ThermalLevel::WARNING); + bool ret = systemLoadStatus_->IsSystemLoadAllowed(); EXPECT_EQ(ret, false); } catch (...) { EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 FAILED"; + GTEST_LOG_(INFO) << "IsSystemLoadAllowedTest002 FAILED"; } - GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 End"; + GTEST_LOG_(INFO) << "IsSystemLoadAllowedTest002 End"; } /** - * @tc.name: IsLoadStatusUnderHotTest003 - * @tc.desc: Verify the IsLoadStatusUnderHot function + * @tc.name: IsSystemLoadAllowedTest003 + * @tc.desc: Verify the IsSystemLoadAllowed function * @tc.type: FUNC * @tc.require: I6JPKG */ -HWTEST_F(SytemLoadTest, IsLoadStatusUnderHotTest003, TestSize.Level1) +HWTEST_F(SytemLoadTest, IsSystemLoadAllowedTest003, TestSize.Level1) { - GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 Start"; + GTEST_LOG_(INFO) << "IsSystemLoadAllowedTest003 Start"; try { - SystemLoadStatus_->Setload(1); - bool ret = SystemLoadStatus_->IsLoadStatusUnderHot(); + systemLoadStatus_->Setload(PowerMgr::ThermalLevel::NORMAL); + bool ret = systemLoadStatus_->IsSystemLoadAllowed(); EXPECT_EQ(ret, true); } catch (...) { EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 FAILED"; + GTEST_LOG_(INFO) << "IsSystemLoadAllowedTest003 FAILED"; } - GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 End"; + GTEST_LOG_(INFO) << "IsSystemLoadAllowedTest003 End"; } /** - * @tc.name: IsLoadStatusUnderHotTest004 - * @tc.desc: Verify the IsLoadStatusUnderHot function + * @tc.name: IsSystemLoadAllowedTest004 + * @tc.desc: Verify the IsSystemLoadAllowed function * @tc.type: FUNC * @tc.require: I6JPKG */ -HWTEST_F(SytemLoadTest, IsLoadStatusUnderHotTest004, TestSize.Level1) +HWTEST_F(SytemLoadTest, IsSystemLoadAllowedTest004, TestSize.Level1) { - GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest004 Start"; - SystemLoadStatus_->Setload(10); + GTEST_LOG_(INFO) << "IsSystemLoadAllowedTest004 Start"; + systemLoadStatus_->Setload(PowerMgr::ThermalLevel::OVERHEATED); STOPPED_TYPE process = STOPPED_IN_THUMB; - bool ret = SystemLoadStatus_->IsLoadStatusUnderHot(process); + bool ret = systemLoadStatus_->IsSystemLoadAllowed(process); EXPECT_EQ(ret, false); - GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest004 End"; + GTEST_LOG_(INFO) << "IsSystemLoadAllowedTest004 End"; } /** - * @tc.name: IsLoadStatusUnderHotTest005 - * @tc.desc: Verify the IsLoadStatusUnderHot function + * @tc.name: IsSystemLoadAllowedTest005 + * @tc.desc: Verify the IsSystemLoadAllowed function * @tc.type: FUNC * @tc.require: I6JPKG */ -HWTEST_F(SytemLoadTest, IsLoadStatusUnderHotTest005, TestSize.Level1) +HWTEST_F(SytemLoadTest, IsSystemLoadAllowedTest005, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "IsSystemLoadAllowedTest005 Start"; + systemLoadStatus_->Setload(PowerMgr::ThermalLevel::OVERHEATED); + STOPPED_TYPE process = STOPPED_IN_SYNC; + bool ret = systemLoadStatus_->IsSystemLoadAllowed(process); + EXPECT_EQ(ret, false); + GTEST_LOG_(INFO) << "IsSystemLoadAllowedTest005 End"; +} + +/** + * @tc.name: IsSystemLoadAllowedTest006 + * @tc.desc: Verify the IsSystemLoadAllowed function + * @tc.type: FUNC + * @tc.require: ICR23A + */ +HWTEST_F(SytemLoadTest, IsSystemLoadAllowedTest006, TestSize.Level1) { - GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest005 Start"; - SystemLoadStatus_->Setload(10); + GTEST_LOG_(INFO) << "IsSystemLoadAllowedTest006 Start"; + systemLoadStatus_->Setload(PowerMgr::ThermalLevel::HOT); STOPPED_TYPE process = STOPPED_IN_SYNC; - bool ret = SystemLoadStatus_->IsLoadStatusUnderHot(process); + bool ret = systemLoadStatus_->IsSystemLoadAllowed(process, PowerMgr::ThermalLevel::WARM); EXPECT_EQ(ret, false); - GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest005 End"; + GTEST_LOG_(INFO) << "IsSystemLoadAllowedTest006 End"; } -HWTEST_F(SytemLoadTest, IsLoadStatusUnderNormalTest001, TestSize.Level1) +/** + * @tc.name: GetSystemloadLevel + * @tc.desc: Verify the GetSystemloadLevel function + * @tc.type: FUNC + * @tc.require: ICR23A + */ +HWTEST_F(SytemLoadTest, GetSystemloadLevel, TestSize.Level1) { - SystemLoadStatus_->Setload(SYSTEMLOADLEVEL_NORMAL); - bool ret = SystemLoadStatus_->IsLoadStatusUnderNormal(); - EXPECT_TRUE(ret); + GTEST_LOG_(INFO) << "GetSystemloadLevel Start"; + try { + systemLoadStatus_->GetSystemloadLevel(); + EXPECT_TRUE(true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "GetSystemloadLevel FAILED"; + } + GTEST_LOG_(INFO) << "GetSystemloadLevel End"; } -HWTEST_F(SytemLoadTest, IsLoadStatusUnderNormalTest002, TestSize.Level1) +/** + * @tc.name: SetloadAndGetloadTest + * @tc.desc: Verify the SetloadAndGetloadTest function + * @tc.type: FUNC + * @tc.require: ICR23A + */ +HWTEST_F(SytemLoadTest, SetloadAndGetloadTest, TestSize.Level1) { - SystemLoadStatus_->Setload(SYSTEMLOADLEVEL_NORMAL + 1); - bool ret = SystemLoadStatus_->IsLoadStatusUnderNormal(); - EXPECT_FALSE(ret); + GTEST_LOG_(INFO) << "SetloadAndGetloadTest Start"; + try { + systemLoadStatus_->Setload(PowerMgr::ThermalLevel::COOL); + EXPECT_EQ(systemLoadStatus_->Getload(), PowerMgr::ThermalLevel::COOL); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "SetloadAndGetloadTest FAILED"; + } + GTEST_LOG_(INFO) << "SetloadAndGetloadTest End"; } -HWTEST_F(SytemLoadTest, IsLoadStatusUnderNormalTest003, TestSize.Level1) +/** + * @tc.name: SetDataSyncerTest + * @tc.desc: Verify the SetDataSyncerTest function + * @tc.type: FUNC + * @tc.require: ICR23A + */ +HWTEST_F(SytemLoadTest, SetDataSyncerTest, TestSize.Level1) { - SystemLoadStatus_->Setload(SYSTEMLOADLEVEL_NORMAL - 1); - bool ret = SystemLoadStatus_->IsLoadStatusUnderNormal(); - EXPECT_TRUE(ret); + GTEST_LOG_(INFO) << "SetDataSyncerTest Start"; + try { + auto dataSyncManager = std::make_shared(); + systemLoadEvent_->SetDataSyncer(dataSyncManager); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "SetDataSyncerTest FAILED"; + } + GTEST_LOG_(INFO) << "SetDataSyncerTest End"; } +/** + * @tc.name: InitSystemloadTest + * @tc.desc: Verify the InitSystemloadTest function + * @tc.type: FUNC + * @tc.require: ICR23A + */ +HWTEST_F(SytemLoadTest, InitSystemloadTest, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "InitSystemloadTest Start"; + try { + auto dataSyncManager = std::make_shared(); + systemLoadStatus_->InitSystemload(dataSyncManager); + EXPECT_TRUE(true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "InitSystemloadTest FAILED"; + } + GTEST_LOG_(INFO) << "InitSystemloadTest End"; +} +#endif } // namespace OHOS::FileManagement::CloudSync::Test \ No newline at end of file diff --git a/test/unittests/cloudsync_sa/transport/BUILD.gn b/test/unittests/cloudsync_sa/transport/BUILD.gn index c345d97cc..2f17f3e98 100644 --- a/test/unittests/cloudsync_sa/transport/BUILD.gn +++ b/test/unittests/cloudsync_sa/transport/BUILD.gn @@ -87,9 +87,11 @@ ohos_unittest("cloud_sync_service_transport_manager_test") { external_deps += [ "hicollie:libhicollie" ] defines += [ "HICOLLIE_ENABLE" ] } - if (cloudsync_service_resource_schedule) { - external_deps += [ "resource_schedule_service:ressched_client" ] - defines += [ "CLOUDSYNC_SERVICE_RESOURCE_SCHEDULE" ] + if (support_thermal_manager) { + external_deps += [ "bundle_framework:appexecfwk_base" ] + external_deps += [ "thermal_manager:thermalmgr_listener" ] + external_deps += [ "thermal_manager:thermalsrv_client" ] + defines += [ "support_thermal_manager" ] } use_exceptions = true } @@ -166,9 +168,11 @@ ohos_unittest("cloud_sync_service_transport_softbus_test") { external_deps += [ "hicollie:libhicollie" ] defines += [ "HICOLLIE_ENABLE" ] } - if (cloudsync_service_resource_schedule) { - external_deps += [ "resource_schedule_service:ressched_client" ] - defines += [ "CLOUDSYNC_SERVICE_RESOURCE_SCHEDULE" ] + if (support_thermal_manager) { + external_deps += [ "bundle_framework:appexecfwk_base" ] + external_deps += [ "thermal_manager:thermalmgr_listener" ] + external_deps += [ "thermal_manager:thermalsrv_client" ] + defines += [ "support_thermal_manager" ] } if (dfs_service_feature_enable_cloud_adapter) { defines += [ "CLOUD_ADAPTER_ENABLED" ] -- Gitee