From 8e19a85c8a9f1d5e440d497e16b642bd9e69c9e3 Mon Sep 17 00:00:00 2001 From: wangbaidong Date: Thu, 12 Jun 2025 20:40:51 +0800 Subject: [PATCH] =?UTF-8?q?=E9=98=B2=E6=9A=B4=E7=B1=BB=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: wangbaidong --- common/include/dm_error_type.h | 4 +- .../authentication_v2/dm_freeze_process.h | 16 +- .../auth_stages/auth_acl.cpp | 8 +- .../auth_stages/auth_negotiate.cpp | 7 +- .../auth_stages/auth_pin_auth.cpp | 13 -- .../authentication_v2/dm_freeze_process.cpp | 155 +++++++-------- .../src/ipc/standard/ipc_server_stub.cpp | 4 - test/unittest/BUILD.gn | 22 ++ test/unittest/UTTest_freeze_process.cpp | 188 ++++++++++++++++++ test/unittest/UTTest_freeze_process.h | 37 ++++ 10 files changed, 340 insertions(+), 114 deletions(-) create mode 100644 test/unittest/UTTest_freeze_process.cpp create mode 100644 test/unittest/UTTest_freeze_process.h diff --git a/common/include/dm_error_type.h b/common/include/dm_error_type.h index cd5225aed..b0a386431 100644 --- a/common/include/dm_error_type.h +++ b/common/include/dm_error_type.h @@ -135,12 +135,12 @@ enum { ERR_DM_SHOW_CONFIRM_FAILED = 969298347, ERR_DM_PARSE_MESSAGE_FAILED = 969298348, ERR_DM_GET_BMS_FAILED = 969298349, - ERR_DM_GET_BUNDLE_NAME_FAILED = 969298354, ERR_DM_DESERIAL_CERT_FAILED = 969298350, ERR_DM_VERIFY_CERT_FAILED = 969298351, ERR_DM_GET_PARAM_FAILED = 969298352, ERR_DM_VERIFY_SAME_ACCOUNT_FAILED = 969298353, - ERR_DM_DEVICE_FREEZED = 969298355, + ERR_DM_GET_BUNDLE_NAME_FAILED = 969298354, + ERR_DM_DEVICE_FROZEN = 969298355, ERR_DM_SOCKET_IN_USED = 969298356, }; } // namespace DistributedHardware diff --git a/services/implementation/include/authentication_v2/dm_freeze_process.h b/services/implementation/include/authentication_v2/dm_freeze_process.h index 3c254d4e2..5762a7721 100644 --- a/services/implementation/include/authentication_v2/dm_freeze_process.h +++ b/services/implementation/include/authentication_v2/dm_freeze_process.h @@ -56,28 +56,30 @@ typedef struct BindFailedEvents { class FreezeProcess { DM_DECLARE_SINGLE_INSTANCE_BASE(FreezeProcess); public: - int32_t SyncFreezeData(); - bool IsFreezed(const std::string &bundleName, int32_t deviceType); - int32_t CleanFreezeRecord(const std::string &bundleName, int32_t deviceType); - int32_t DeleteFreezeRecord(const std::string &bundleName, int32_t deviceType); - int32_t UpdateFreezeRecord(const std::string &bundleName, int32_t deviceType); + bool IsFrozen(); + int32_t DeleteFreezeRecord(); + int32_t UpdateFreezeRecord(); private: FreezeProcess() = default; ~FreezeProcess() = default; - void ConvertJsonToDeviceFreezeState(const std::string &result, DeviceFreezeState &freezeStateObj); - void ConvertJsonToBindFailedEvents(const std::string &result, BindFailedEvents &bindFailedEvents); + int32_t SyncFreezeData(); + int32_t ConvertJsonToDeviceFreezeState(const std::string &result, DeviceFreezeState &freezeStateObj); + int32_t ConvertJsonToBindFailedEvents(const std::string &result, BindFailedEvents &bindFailedEvents); void ConvertBindFailedEventsToJson(const BindFailedEvents &value, std::string &result); void ConvertDeviceFreezeStateToJson(const DeviceFreezeState &value, std::string &result); + int32_t CleanFreezeRecord(int64_t nowTime); int32_t CleanBindFailedEvents(int64_t reservedDataTimeStamp); int32_t CleanFreezeState(int64_t reservedDataTimeStamp); int32_t UpdateFreezeState(int64_t nowTime); void CalculateNextFreezeTime(int64_t nowFreezeTime, int64_t &nextFreezeTime); private: + bool isSynced_ = false; DeviceFreezeState freezeStateCache_; BindFailedEvents bindFailedEventsCache_; std::mutex freezeStateCacheMtx_; std::mutex bindFailedEventsCacheMtx_; + std::mutex isSyncedMtx_; }; } // namespace DistributedHardware diff --git a/services/implementation/src/authentication_v2/auth_stages/auth_acl.cpp b/services/implementation/src/authentication_v2/auth_stages/auth_acl.cpp index 73dedccd0..87b5b33fa 100644 --- a/services/implementation/src/authentication_v2/auth_stages/auth_acl.cpp +++ b/services/implementation/src/authentication_v2/auth_stages/auth_acl.cpp @@ -114,13 +114,11 @@ int32_t AuthSinkFinishState::Action(std::shared_ptr context) LOGI("reason: %{public}d", context->reason); if (context->reason == DM_OK) { context->state = static_cast(GetStateType()); - ret = FreezeProcess::GetInstance().DeleteFreezeRecord(context->accessee.bundleName, - context->accessee.deviceType); + ret = FreezeProcess::GetInstance().DeleteFreezeRecord(); LOGI("DeleteFreezeRecord ret: %{public}d", ret); } - if (context->reason != DM_OK && context->reason != ERR_DM_DEVICE_FREEZED) { - ret = FreezeProcess::GetInstance().UpdateFreezeRecord(context->accessee.bundleName, - context->accessee.deviceType); + if (context->reason == ERR_DM_BIND_PIN_CODE_ERROR) { + ret = FreezeProcess::GetInstance().UpdateFreezeRecord(); LOGI("UpdateFreezeData ret: %{public}d", ret); } SinkFinish(context); diff --git a/services/implementation/src/authentication_v2/auth_stages/auth_negotiate.cpp b/services/implementation/src/authentication_v2/auth_stages/auth_negotiate.cpp index 0639821f5..ae747211e 100644 --- a/services/implementation/src/authentication_v2/auth_stages/auth_negotiate.cpp +++ b/services/implementation/src/authentication_v2/auth_stages/auth_negotiate.cpp @@ -159,7 +159,6 @@ int32_t AuthSinkNegotiateStateMachine::RespQueryAcceseeIds(std::shared_ptraccessee.language = DmLanguageManager::GetInstance().GetSystemLanguage(); context->accessee.deviceName = context->listener->GetLocalDisplayDeviceNameForPrivacy(); context->accessee.networkId = context->softbusConnector->GetLocalDeviceNetworkId(); - context->accessee.deviceType = context->softbusConnector->GetLocalDeviceTypeId(); return DM_OK; } @@ -226,9 +225,9 @@ int32_t VerifyCertificate(std::shared_ptr context) int32_t AuthSinkNegotiateStateMachine::Action(std::shared_ptr context) { LOGI("AuthSinkNegotiateStateMachine::Action sessionid %{public}d", context->sessionId); - if (FreezeProcess::GetInstance().IsFreezed(context->accessee.bundleName, context->accessee.deviceType)) { - LOGE("Device is Freezed"); - return ERR_DM_DEVICE_FREEZED; + if (FreezeProcess::GetInstance().IsFrozen()) { + LOGE("Device is Frozen"); + return ERR_DM_DEVICE_FROZEN; } // 1. Create an authorization timer if (context->timer != nullptr) { diff --git a/services/implementation/src/authentication_v2/auth_stages/auth_pin_auth.cpp b/services/implementation/src/authentication_v2/auth_stages/auth_pin_auth.cpp index 913e6cd11..9c11a753a 100644 --- a/services/implementation/src/authentication_v2/auth_stages/auth_pin_auth.cpp +++ b/services/implementation/src/authentication_v2/auth_stages/auth_pin_auth.cpp @@ -22,7 +22,6 @@ #include "dm_auth_state.h" #include "dm_auth_state_machine.h" #include "dm_dialog_manager.h" -#include "dm_freeze_process.h" #include "dm_log.h" #include "dm_negotiate_process.h" #include "dm_random.h" @@ -182,10 +181,6 @@ int32_t AuthSinkPinAuthStartState::Action(std::shared_ptr context LOGE("AuthSinkPinAuthStartState::Action invalid parameter."); return ERR_DM_INPUT_PARA_INVALID; } - if (FreezeProcess::GetInstance().CleanFreezeRecord(context->accessee.bundleName, - context->accessee.deviceType) != DM_OK) { - LOGE("CleanFreezeRecord failed."); - } // process pincode auth auto ret = context->hiChainAuthConnector->ProcessCredData(context->requestId, context->transmitData); if (ret != DM_OK) { @@ -762,10 +757,6 @@ int32_t AuthSinkReverseUltrasonicDoneState::Action(std::shared_ptrtimer->DeleteTimer(std::string(WAIT_REQUEST_TIMEOUT_TASK)); context->timer->DeleteTimer(std::string(GET_ULTRASONIC_PIN_TIMEOUT_TASK)); context->pinNegotiateStarted = true; - if (FreezeProcess::GetInstance().CleanFreezeRecord(context->accessee.bundleName, - context->accessee.deviceType) != DM_OK) { - LOGE("CleanFreezeRecord failed."); - } auto ret = context->hiChainAuthConnector->ProcessCredData(context->requestId, context->transmitData); if (ret != DM_OK) { LOGE("AuthSinkPinAuthStartState::Action call ProcessCredData err"); @@ -821,10 +812,6 @@ int32_t AuthSinkForwardUltrasonicDoneState::Action(std::shared_ptrtimer->DeleteTimer(std::string(WAIT_REQUEST_TIMEOUT_TASK)); context->timer->DeleteTimer(std::string(GET_ULTRASONIC_PIN_TIMEOUT_TASK)); context->pinNegotiateStarted = true; - if (FreezeProcess::GetInstance().CleanFreezeRecord(context->accessee.bundleName, - context->accessee.deviceType) != DM_OK) { - LOGE("CleanFreezeRecord failed."); - } auto ret = context->hiChainAuthConnector->ProcessCredData(context->requestId, context->transmitData); if (ret != DM_OK) { LOGE("AuthSinkForwardUltrasonicDoneState::Action call ProcessCredData err"); diff --git a/services/implementation/src/authentication_v2/dm_freeze_process.cpp b/services/implementation/src/authentication_v2/dm_freeze_process.cpp index 354073583..20d627fa3 100644 --- a/services/implementation/src/authentication_v2/dm_freeze_process.cpp +++ b/services/implementation/src/authentication_v2/dm_freeze_process.cpp @@ -30,15 +30,14 @@ constexpr const char* START_FREEZE_TIME_KEY = "startFreezeTimeStamp"; constexpr const char* STOP_FREEZE_TIME_KEY = "stopFreezeTimeStamp"; constexpr const char* FAILED_TIMES_STAMPS_KEY = "failedTimeStamps"; constexpr const char* FREEZE_TIMES_STAMPS_KEY = "freezeTimeStamps"; -constexpr const char* CAST_BUNDLE_NAME = "cast_engine_service"; -constexpr int32_t MAX_CONTINUEOUS_BIND_FAILED_NUM = 2; +constexpr int32_t MAX_CONTINUOUS_BIND_FAILED_NUM = 2; constexpr int64_t CONTINUEOUS_FAILED_INTERVAL = 6 * 60; constexpr int64_t DATA_REFRESH_INTERVAL = 20 * 60; -constexpr int64_t NOT_FREEZE_TIME = 0; -constexpr int64_t FIRST_FREEZE_TIME = 60; -constexpr int64_t SECOND_FREEZE_TIME = 3 * 60; -constexpr int64_t THIRD_FREEZE_TIME = 5 * 60; -constexpr int64_t MAX_FREEZE_TIME = 10 * 60; +constexpr int64_t NOT_FREEZE_DURATION_SEC = 0; +constexpr int64_t FIRST_FREEZE_DURATION_SEC = 60; +constexpr int64_t SECOND_FREEZE_DURATION_SEC = 3 * 60; +constexpr int64_t THIRD_FREEZE_DURATION_SEC = 5 * 60; +constexpr int64_t MAX_FREEZE_DURATION_SEC = 10 * 60; } DM_IMPLEMENT_SINGLE_INSTANCE(FreezeProcess); @@ -53,7 +52,11 @@ int32_t FreezeProcess::SyncFreezeData() return ret; } DeviceFreezeState freezeStateObj; - ConvertJsonToDeviceFreezeState(freezeStatesValue, freezeStateObj); + ret = ConvertJsonToDeviceFreezeState(freezeStatesValue, freezeStateObj); + if (ret != DM_OK) { + LOGE("ConvertJsonToDeviceFreezeState, ret: %{public}d", ret); + return ret; + } { std::lock_guard lock(freezeStateCacheMtx_); freezeStateCache_ = freezeStateObj; @@ -65,90 +68,92 @@ int32_t FreezeProcess::SyncFreezeData() return ret; } BindFailedEvents bindFailedEventsObj; - ConvertJsonToBindFailedEvents(bindFailedEventsValue, bindFailedEventsObj); + ret = ConvertJsonToBindFailedEvents(bindFailedEventsValue, bindFailedEventsObj); + if (ret != DM_OK) { + LOGE("ConvertJsonToBindFailedEvents, ret: %{public}d", ret); + return ret; + } std::lock_guard lock(bindFailedEventsCacheMtx_); bindFailedEventsCache_ = bindFailedEventsObj; LOGI("Sync freeze data success"); return DM_OK; } -void FreezeProcess::ConvertJsonToDeviceFreezeState(const std::string &result, DeviceFreezeState &freezeStateObj) +int32_t FreezeProcess::ConvertJsonToDeviceFreezeState(const std::string &result, DeviceFreezeState &freezeStateObj) { if (result.empty()) { LOGE("result is empty"); - return; + return ERR_DM_FAILED; } - cJSON *root = cJSON_Parse(result.c_str()); - if (root == nullptr) { - LOGE("cJSON_Parse failed"); - return; + JsonObject resultJson(result); + if (resultJson.IsDiscarded()) { + LOGE("resultJson parse failed"); + return ERR_DM_FAILED; } - cJSON *startFreezeTimeStampItem = cJSON_GetObjectItemCaseSensitive(root, START_FREEZE_TIME_KEY); - if (startFreezeTimeStampItem != nullptr && cJSON_IsNumber(startFreezeTimeStampItem)) { - freezeStateObj.startFreezeTimeStamp = startFreezeTimeStampItem->valueint; + if (IsInt64(resultJson, START_FREEZE_TIME_KEY)) { + freezeStateObj.startFreezeTimeStamp = resultJson[START_FREEZE_TIME_KEY].Get(); } - cJSON *stopFreezeTimeStampItem = cJSON_GetObjectItemCaseSensitive(root, STOP_FREEZE_TIME_KEY); - if (stopFreezeTimeStampItem != nullptr && cJSON_IsNumber(stopFreezeTimeStampItem)) { - freezeStateObj.stopFreezeTimeStamp = stopFreezeTimeStampItem->valueint; + if (IsInt64(resultJson, STOP_FREEZE_TIME_KEY)) { + freezeStateObj.stopFreezeTimeStamp = resultJson[STOP_FREEZE_TIME_KEY].Get(); } LOGI("ConvertJsonToDeviceFreezeState success"); - cJSON_Delete(root); + return DM_OK; } -void FreezeProcess::ConvertJsonToBindFailedEvents(const std::string &result, BindFailedEvents &bindFailedEventsObj) +int32_t FreezeProcess::ConvertJsonToBindFailedEvents(const std::string &result, BindFailedEvents &bindFailedEventsObj) { if (result.empty()) { LOGE("result is empty"); - return; - } - cJSON *root = cJSON_Parse(result.c_str()); - if (root == nullptr) { - LOGE("cJSON_Parse failed"); - return; - } - cJSON *failedTimeStampsJson = cJSON_GetObjectItem(root, FAILED_TIMES_STAMPS_KEY); - if (failedTimeStampsJson != nullptr && cJSON_IsArray(failedTimeStampsJson)) { - cJSON *item; - cJSON_ArrayForEach(item, failedTimeStampsJson) - { - bindFailedEventsObj.failedTimeStamps.push_back(item->valueint); - } + return ERR_DM_FAILED; } - cJSON *freezeTimeStampsJson = cJSON_GetObjectItem(root, FREEZE_TIMES_STAMPS_KEY); - if (freezeTimeStampsJson != nullptr && cJSON_IsArray(freezeTimeStampsJson)) { - cJSON *item; - cJSON_ArrayForEach(item, freezeTimeStampsJson) - { - bindFailedEventsObj.freezeTimeStamps.push_back(item->valueint); - } + JsonObject resultJson(result); + if (resultJson.IsDiscarded()) { + LOGE("resultJson parse failed"); + return ERR_DM_FAILED; + } + if (IsArray(resultJson, FAILED_TIMES_STAMPS_KEY)) { + std::vector failedTimeStampsTmp; + resultJson[FAILED_TIMES_STAMPS_KEY].Get(failedTimeStampsTmp); + bindFailedEventsObj.failedTimeStamps = failedTimeStampsTmp; + } + if (IsArray(resultJson, FREEZE_TIMES_STAMPS_KEY)) { + std::vector freezeTimeStampsTmp; + resultJson[FREEZE_TIMES_STAMPS_KEY].Get(freezeTimeStampsTmp); + bindFailedEventsObj.freezeTimeStamps = freezeTimeStampsTmp; } LOGI("ConvertJsonToBindFailedEvents success"); - cJSON_Delete(root); + return DM_OK; } -bool FreezeProcess::IsFreezed(const std::string &bundleName, int32_t deviceType) +bool FreezeProcess::IsFrozen() { - if (bundleName == CAST_BUNDLE_NAME && deviceType == DEVICE_TYPE_TV) { - LOGI("device is TV, business is cast+, no need freeze"); - return false; + { + std::lock_guard lock(isSyncedMtx_); + if (!isSynced_) { + SyncFreezeData(); + isSynced_ = true; + } } - std::lock_guard lock(freezeStateCacheMtx_); - if (bindFailedEventsCache_.IsEmpty()) { - LOGI("bindFailedEventsCache is empty"); - return false; + int64_t stopFreezeTimeStamp = 0; + { + std::lock_guard lock(freezeStateCacheMtx_); + if (bindFailedEventsCache_.IsEmpty()) { + LOGI("bindFailedEventsCache is empty"); + return false; + } + stopFreezeTimeStamp = freezeStateCache_.stopFreezeTimeStamp; } int64_t nowTime = GetSecondsSince1970ToNow(); - int64_t stopFreezeTimeStamp = freezeStateCache_.stopFreezeTimeStamp; - return nowTime > stopFreezeTimeStamp ? false : true; + bool isFrozen = nowTime > stopFreezeTimeStamp ? false : true; + if (CleanFreezeRecord(nowTime) != DM_OK) { + LOGE("CleanFreezeRecord failed"); + } + return isFrozen; } -int32_t FreezeProcess::CleanFreezeRecord(const std::string &bundleName, int32_t deviceType) +int32_t FreezeProcess::CleanFreezeRecord(int64_t nowTime) { - if (bundleName == CAST_BUNDLE_NAME && deviceType == DEVICE_TYPE_TV) { - LOGI("device is TV, business is cast+, no need clean"); - return DM_OK; - } - int64_t reservedDataTimeStamp = GetSecondsSince1970ToNow() - DATA_REFRESH_INTERVAL; + int64_t reservedDataTimeStamp = nowTime - DATA_REFRESH_INTERVAL; if (CleanBindFailedEvents(reservedDataTimeStamp) != DM_OK) { LOGE("CleanBindFailedEvents failed"); return ERR_DM_FAILED; @@ -233,12 +238,8 @@ void FreezeProcess::ConvertDeviceFreezeStateToJson(const DeviceFreezeState &valu result = SafetyDump(jsonObj); } -int32_t FreezeProcess::DeleteFreezeRecord(const std::string &bundleName, int32_t deviceType) +int32_t FreezeProcess::DeleteFreezeRecord() { - if (bundleName == CAST_BUNDLE_NAME && deviceType == DEVICE_TYPE_TV) { - LOGI("device is TV, business is cast+, no need delete"); - return DM_OK; - } if (KVAdapterManager::GetInstance().DeleteFreezeData(FREEZE_STATE_KEY) != DM_OK) { LOGE("delete freezeStates data failed"); return ERR_DM_FAILED; @@ -256,12 +257,8 @@ int32_t FreezeProcess::DeleteFreezeRecord(const std::string &bundleName, int32_t return DM_OK; } -int32_t FreezeProcess::UpdateFreezeRecord(const std::string &bundleName, int32_t deviceType) +int32_t FreezeProcess::UpdateFreezeRecord() { - if (bundleName == CAST_BUNDLE_NAME && deviceType == DEVICE_TYPE_TV) { - LOGI("device is TV, business is cast+, no need update"); - return DM_OK; - } int64_t nowTime = GetSecondsSince1970ToNow(); std::lock_guard lock(bindFailedEventsCacheMtx_); BindFailedEvents bindFailedEventsTmp = bindFailedEventsCache_; @@ -273,7 +270,7 @@ int32_t FreezeProcess::UpdateFreezeRecord(const std::string &bundleName, int32_t bindFailedEventsTmp.failedTimeStamps.end(), [nowTime, lastFreezeTimeStamps]( int64_t v) { return v > nowTime - CONTINUEOUS_FAILED_INTERVAL && v > lastFreezeTimeStamps; }); - if (continueBindFailedNum < MAX_CONTINUEOUS_BIND_FAILED_NUM) { + if (continueBindFailedNum < MAX_CONTINUOUS_BIND_FAILED_NUM) { bindFailedEventsTmp.failedTimeStamps.push_back(nowTime); std::string bindFailedEventsStr = ""; ConvertBindFailedEventsToJson(bindFailedEventsTmp, bindFailedEventsStr); @@ -317,17 +314,17 @@ int32_t FreezeProcess::UpdateFreezeState(int64_t nowTime) void FreezeProcess::CalculateNextFreezeTime(int64_t nowFreezeTime, int64_t &nextFreezeTime) { switch (nowFreezeTime) { - case NOT_FREEZE_TIME: - nextFreezeTime = FIRST_FREEZE_TIME; + case NOT_FREEZE_DURATION_SEC: + nextFreezeTime = FIRST_FREEZE_DURATION_SEC; break; - case FIRST_FREEZE_TIME: - nextFreezeTime = SECOND_FREEZE_TIME; + case FIRST_FREEZE_DURATION_SEC: + nextFreezeTime = SECOND_FREEZE_DURATION_SEC; break; - case SECOND_FREEZE_TIME: - nextFreezeTime = THIRD_FREEZE_TIME; + case SECOND_FREEZE_DURATION_SEC: + nextFreezeTime = THIRD_FREEZE_DURATION_SEC; break; default: - nextFreezeTime = MAX_FREEZE_TIME; + nextFreezeTime = MAX_FREEZE_DURATION_SEC; break; } } diff --git a/services/service/src/ipc/standard/ipc_server_stub.cpp b/services/service/src/ipc/standard/ipc_server_stub.cpp index b6b9fa9fa..c85383af7 100644 --- a/services/service/src/ipc/standard/ipc_server_stub.cpp +++ b/services/service/src/ipc/standard/ipc_server_stub.cpp @@ -33,7 +33,6 @@ #include "device_name_manager.h" #include "dm_error_type.h" #include "dm_device_info.h" -#include "dm_freeze_process.h" #include "ffrt.h" #include #include @@ -188,9 +187,6 @@ void IpcServerStub::OnAddSystemAbility(int32_t systemAbilityId, const std::strin #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE)) if (systemAbilityId == DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID) { KVAdapterManager::GetInstance().ReInit(); - if (FreezeProcess::GetInstance().SyncFreezeData() != DM_OK) { - LOGE("SyncFreezeData failed."); - } return; } #endif diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 8e572f9a3..79713a576 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -69,6 +69,7 @@ group("unittest") { ":UTTest_dm_transport", ":UTTest_dm_transport_msg", ":UTTest_dp_inited_callback", + ":UTTest_freeze_process", ":UTTest_hichain_auth_connector", ":UTTest_hichain_connector", ":UTTest_hichain_listener", @@ -2348,3 +2349,24 @@ ohos_static_library("device_manager_test_common") { part_name = "device_manager" } ## Build device_manager_test_common.a }}} + +## UnitTest UTTest_freeze_process {{{ + +ohos_unittest("UTTest_freeze_process") { + module_out_path = module_out_path + + sources = [ "UTTest_freeze_process.cpp" ] + + deps = [ ":device_manager_test_common" ] + + external_deps = [ + "device_auth:deviceauth_sdk", + "device_info_manager:distributed_device_profile_common", + "device_info_manager:distributed_device_profile_sdk", + "ffrt:libffrt", + "googletest:gmock", + "hilog:libhilog", + ] +} + +## UnitTest UTTest_freeze_process }}} diff --git a/test/unittest/UTTest_freeze_process.cpp b/test/unittest/UTTest_freeze_process.cpp new file mode 100644 index 000000000..3e13b0441 --- /dev/null +++ b/test/unittest/UTTest_freeze_process.cpp @@ -0,0 +1,188 @@ +/* + * Copyright (c) 2025 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 "UTTest_freeze_process.h" + +#include "dm_constants.h" + +namespace OHOS { +namespace DistributedHardware { +void FreezeProcessTest::SetUp() +{ +} + +void FreezeProcessTest::TearDown() +{ +} + +void FreezeProcessTest::SetUpTestCase() +{ +} + +void FreezeProcessTest::TearDownTestCase() +{ +} + +namespace { +constexpr int64_t DATA_REFRESH_INTERVAL = 20 * 60; +} +HWTEST_F(FreezeProcessTest, UpdateFreezeRecord_001, testing::ext::TestSize.Level0) +{ + int64_t nowTime = 1633072800 ; + BindFailedEvents bindFailedEventsCache; + bindFailedEventsCache.failedTimeStamps = {1633072700, 1633072800}; + bindFailedEventsCache.freezeTimeStamps = {1633072600}; + FreezeProcess freezeProcess; + freezeProcess.bindFailedEventsCache_ = bindFailedEventsCache; + int32_t result = freezeProcess.UpdateFreezeRecord(); + EXPECT_EQ(result, ERR_DM_FAILED); +} + +HWTEST_F(FreezeProcessTest, UpdateFreezeRecord_002, testing::ext::TestSize.Level0) +{ + int64_t nowTime = 1633072800 ; + BindFailedEvents bindFailedEventsCache; + bindFailedEventsCache.failedTimeStamps = {1633072700, 1633072800, 1633072900}; + bindFailedEventsCache.freezeTimeStamps = {1633072600}; + FreezeProcess freezeProcess; + freezeProcess.bindFailedEventsCache_ = bindFailedEventsCache; + int32_t result = freezeProcess.UpdateFreezeRecord(); + EXPECT_EQ(result, ERR_DM_FAILED); +} + +HWTEST_F(FreezeProcessTest, UpdateFreezeRecord_003, testing::ext::TestSize.Level0) +{ + int64_t nowTime = 1633072800 ; + BindFailedEvents bindFailedEventsCache; + bindFailedEventsCache.failedTimeStamps = {1633072700}; + bindFailedEventsCache.freezeTimeStamps = {1633072600}; + FreezeProcess freezeProcess; + freezeProcess.bindFailedEventsCache_ = bindFailedEventsCache; + int32_t result = freezeProcess.UpdateFreezeRecord(); + EXPECT_EQ(result, ERR_DM_FAILED); +} + +HWTEST_F(FreezeProcessTest, ConvertJsonToBindFailedEvents_001, testing::ext::TestSize.Level0) +{ + std::string emptyResult = ""; + BindFailedEvents bindFailedEventsObj; + FreezeProcess freezeProcess; + int32_t result = freezeProcess.ConvertJsonToBindFailedEvents(emptyResult, bindFailedEventsObj); + EXPECT_EQ(result, ERR_DM_FAILED); +} + +HWTEST_F(FreezeProcessTest, ConvertJsonToBindFailedEvents_002, testing::ext::TestSize.Level0) +{ + std::string invalidJsonResult = "invalid_json"; + BindFailedEvents bindFailedEventsObj; + FreezeProcess freezeProcess; + int32_t result = freezeProcess.ConvertJsonToBindFailedEvents(invalidJsonResult, bindFailedEventsObj); + EXPECT_EQ(result, ERR_DM_FAILED); +} + +HWTEST_F(FreezeProcessTest, ConvertJsonToBindFailedEvents_003, testing::ext::TestSize.Level0) +{ + std::string validJsonResult = R"({"failedTimeStamps": [123456, 789012]})"; + BindFailedEvents bindFailedEventsObj; + FreezeProcess freezeProcess; + int32_t result = freezeProcess.ConvertJsonToBindFailedEvents(validJsonResult, bindFailedEventsObj); + EXPECT_EQ(result, DM_OK); + EXPECT_EQ(bindFailedEventsObj.failedTimeStamps.size(), 2); + EXPECT_EQ(bindFailedEventsObj.failedTimeStamps[0], 123456); + EXPECT_EQ(bindFailedEventsObj.failedTimeStamps[1], 789012); + EXPECT_EQ(bindFailedEventsObj.freezeTimeStamps.size(), 0); +} + +HWTEST_F(FreezeProcessTest, ConvertJsonToBindFailedEvents_004, testing::ext::TestSize.Level0) +{ + std::string validJsonResult = R"({"freezeTimeStamps": [345678, 901234]})"; + BindFailedEvents bindFailedEventsObj; + FreezeProcess freezeProcess; + int32_t result = freezeProcess.ConvertJsonToBindFailedEvents(validJsonResult, bindFailedEventsObj); + EXPECT_EQ(result, DM_OK); + EXPECT_EQ(bindFailedEventsObj.failedTimeStamps.size(), 0); + EXPECT_EQ(bindFailedEventsObj.freezeTimeStamps.size(), 2); + EXPECT_EQ(bindFailedEventsObj.freezeTimeStamps[0], 345678); + EXPECT_EQ(bindFailedEventsObj.freezeTimeStamps[1], 901234); +} + +HWTEST_F(FreezeProcessTest, ConvertJsonToBindFailedEvents_005, testing::ext::TestSize.Level0) +{ + std::string validJsonResult = R"({"failedTimeStamps": [123456, 789012], + "freezeTimeStamps": [345678, 901234]})"; + BindFailedEvents bindFailedEventsObj; + FreezeProcess freezeProcess; + int32_t result = freezeProcess.ConvertJsonToBindFailedEvents(validJsonResult, bindFailedEventsObj); + EXPECT_EQ(result, DM_OK); + EXPECT_EQ(bindFailedEventsObj.failedTimeStamps.size(), 2); + EXPECT_EQ(bindFailedEventsObj.failedTimeStamps[0], 123456); + EXPECT_EQ(bindFailedEventsObj.failedTimeStamps[1], 789012); + EXPECT_EQ(bindFailedEventsObj.freezeTimeStamps.size(), 2); + EXPECT_EQ(bindFailedEventsObj.freezeTimeStamps[0], 345678); + EXPECT_EQ(bindFailedEventsObj.freezeTimeStamps[1], 901234); +} + +HWTEST_F(FreezeProcessTest, ConvertJsonToDeviceFreezeState_001, testing::ext::TestSize.Level0) +{ + std::string emptyResult = ""; + DeviceFreezeState freezeStateObj; + FreezeProcess freezeProcess; + int32_t result = freezeProcess.ConvertJsonToDeviceFreezeState(emptyResult, freezeStateObj); + EXPECT_EQ(result, ERR_DM_FAILED); +} + +HWTEST_F(FreezeProcessTest, ConvertJsonToDeviceFreezeState_002, testing::ext::TestSize.Level0) +{ + std::string invalidJsonResult = "invalid_json"; + DeviceFreezeState freezeStateObj; + FreezeProcess freezeProcess; + int32_t result = freezeProcess.ConvertJsonToDeviceFreezeState(invalidJsonResult, freezeStateObj); + EXPECT_EQ(result, ERR_DM_FAILED); +} + +HWTEST_F(FreezeProcessTest, ConvertJsonToDeviceFreezeState_003, testing::ext::TestSize.Level0) +{ + std::string validJsonResult = "{\"startFreezeTimeStamp\":1234567890}"; + DeviceFreezeState freezeStateObj; + FreezeProcess freezeProcess; + int32_t result = freezeProcess.ConvertJsonToDeviceFreezeState(validJsonResult, freezeStateObj); + EXPECT_EQ(result, DM_OK); + EXPECT_EQ(freezeStateObj.startFreezeTimeStamp, 1234567890); + EXPECT_EQ(freezeStateObj.stopFreezeTimeStamp, 0); +} + +HWTEST_F(FreezeProcessTest, ConvertJsonToDeviceFreezeState_004, testing::ext::TestSize.Level0) +{ + std::string validJsonResult = "{\"stopFreezeTimeStamp\":9876543210}"; + DeviceFreezeState freezeStateObj; + FreezeProcess freezeProcess; + int32_t result = freezeProcess.ConvertJsonToDeviceFreezeState(validJsonResult, freezeStateObj); + EXPECT_EQ(result, DM_OK); + EXPECT_EQ(freezeStateObj.startFreezeTimeStamp, 0); + EXPECT_EQ(freezeStateObj.stopFreezeTimeStamp, 9876543210); +} + +HWTEST_F(FreezeProcessTest, ConvertJsonToDeviceFreezeState_005, testing::ext::TestSize.Level0) +{ + std::string validJsonResult = "{\"startFreezeTimeStamp\":1234567890,\"stopFreezeTimeStamp\":9876543210}"; + DeviceFreezeState freezeStateObj; + FreezeProcess freezeProcess; + int32_t result = freezeProcess.ConvertJsonToDeviceFreezeState(validJsonResult, freezeStateObj); + EXPECT_EQ(result, DM_OK); + EXPECT_EQ(freezeStateObj.startFreezeTimeStamp, 1234567890); + EXPECT_EQ(freezeStateObj.stopFreezeTimeStamp, 9876543210); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/test/unittest/UTTest_freeze_process.h b/test/unittest/UTTest_freeze_process.h new file mode 100644 index 000000000..df7f2be52 --- /dev/null +++ b/test/unittest/UTTest_freeze_process.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2025 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_FREEZE_PROCESS_TEST_H +#define OHOS_FREEZE_PROCESS_TEST_H + +#include "gtest/gtest.h" +#include "datetime_ex.h" +#include "dm_anonymous.h" +#include "dm_device_info.h" +#include "dm_freeze_process.h" + +namespace OHOS { +namespace DistributedHardware { +class FreezeProcessTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; +} // namespace DistributedHardware +} // namespace OHOS + +#endif // OHOS_FREEZE_PROCESS_TEST_H \ No newline at end of file -- Gitee