diff --git a/brightness_manager/include/brightness_dimming.h b/brightness_manager/include/brightness_dimming.h index 5eb47a27aeb70a8060cdabe23f8f0b88633d8ec8..874ab6f451d10460c55dc90886531a7e54c71ca1 100644 --- a/brightness_manager/include/brightness_dimming.h +++ b/brightness_manager/include/brightness_dimming.h @@ -39,6 +39,7 @@ public: void StartDimming(uint32_t from, uint32_t to, uint32_t duration); void StopDimming(); bool IsDimming() const; + void WaitDimmingDone() const; // this API may trigger thread switching in ffrt uint32_t GetDimmingUpdateTime() const; bool Init(); void Reset(); @@ -61,6 +62,8 @@ private: std::atomic_uint32_t mCurrentStep{}; std::shared_ptr mQueue; std::mutex mAnimatorHandleLock{}; + mutable ffrt::mutex mLock; + mutable ffrt::condition_variable mCondDimmingDone; }; } // namespace DisplayPowerMgr } // namespace OHOS diff --git a/brightness_manager/include/brightness_manager.h b/brightness_manager/include/brightness_manager.h index a5b7894203b1566a20c76bafdced341e10388c5b..1a1be66c589a16d79b25c1bc6dd161e77f6aee3e 100644 --- a/brightness_manager/include/brightness_manager.h +++ b/brightness_manager/include/brightness_manager.h @@ -50,6 +50,7 @@ public: bool IsBrightnessBoosted() const; uint32_t GetBrightness(); uint32_t GetDeviceBrightness(); + void WaitDimmingDone() const; void ClearOffset(); uint32_t SetLightBrightnessThreshold(std::vector threshold, sptr callback); uint32_t GetCurrentDisplayId(uint32_t defaultId) const; diff --git a/brightness_manager/include/brightness_manager_ext.h b/brightness_manager/include/brightness_manager_ext.h index 0a342dd150f76fa4396984a007fdc9f2d3370f75..8d518f324dfbb9aad570d979a57ec53a84560d73 100644 --- a/brightness_manager/include/brightness_manager_ext.h +++ b/brightness_manager/include/brightness_manager_ext.h @@ -50,6 +50,7 @@ public: bool IsBrightnessBoosted() const; uint32_t GetBrightness(); uint32_t GetDeviceBrightness(); + void WaitDimmingDone() const; void ClearOffset(); uint32_t GetCurrentDisplayId(uint32_t defaultId) const; void SetDisplayId(uint32_t id = 0); @@ -93,6 +94,7 @@ public: void* mIsBrightnessBoostedFunc = nullptr; void* mGetBrightnessFunc = nullptr; void* mGetDeviceBrightnessFunc = nullptr; + void* mWaitDimmingDoneFunc = nullptr; void* mClearOffsetFunc = nullptr; void* mGetCurrentDisplayIdFunc = nullptr; void* mSetDisplayIdFunc = nullptr; diff --git a/brightness_manager/include/brightness_service.h b/brightness_manager/include/brightness_service.h index 4e9dc4cfae1d0c2897d43470454ec853b15ac098..11d81f9f46b5eb4602aad3f95f65d25355bca42b 100644 --- a/brightness_manager/include/brightness_service.h +++ b/brightness_manager/include/brightness_service.h @@ -135,6 +135,7 @@ public: bool DiscountBrightness(double discount, uint32_t gradualDuration = 0); double GetDiscount() const; uint32_t GetDimmingUpdateTime() const; + void WaitDimmingDone() const; void ClearOffset(); void UpdateBrightnessSceneMode(BrightnessSceneMode mode); uint32_t GetDisplayId(); diff --git a/brightness_manager/src/brightness_dimming.cpp b/brightness_manager/src/brightness_dimming.cpp index f30f546ae7a65ae29f67e7db6093288a11d6d473..d8dd379f2ba1489efd88589dc4397597ebf8fdc6 100644 --- a/brightness_manager/src/brightness_dimming.cpp +++ b/brightness_manager/src/brightness_dimming.cpp @@ -15,11 +15,14 @@ #include "brightness_dimming.h" +#include + #include "brightness_dimming_callback.h" #include "display_log.h" namespace OHOS { namespace DisplayPowerMgr { +using namespace std::chrono_literals; using namespace PowerMgr; namespace { FFRTHandle g_animatorTaskHandle; @@ -101,6 +104,7 @@ void BrightnessDimming::StartDimming(uint32_t from, uint32_t to, uint32_t durati void BrightnessDimming::StopDimming() { mDimming = false; + mCondDimmingDone.notify_all(); mAnimatorHandleLock.lock(); FFRT_CANCEL(g_animatorTaskHandle, mQueue); mAnimatorHandleLock.unlock(); @@ -117,6 +121,16 @@ bool BrightnessDimming::IsDimming() const return mDimming; } +void BrightnessDimming::WaitDimmingDone() const +{ + std::unique_lock lck(mLock); + while (IsDimming()) { + mCondDimmingDone.wait_for(lck, 600ms); + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "WaitDimmingDone, mDimming=%{public}d, qos=%{public}d", + IsDimming(), ffrt_this_task_get_qos()); + } +} + uint32_t BrightnessDimming::GetDimmingUpdateTime() const { return mUpdateTime; @@ -146,6 +160,7 @@ void BrightnessDimming::NextStep() mCallback->OnChanged(mCurrentBrightness); mCallback->OnEnd(); mDimming = false; + mCondDimmingDone.notify_all(); } else { DISPLAY_HILOGD(FEAT_BRIGHTNESS, "next step last mCurrentBrightness=%{public}u, next=%{public}d", mCurrentBrightness.load(), nextBrightness); @@ -161,6 +176,7 @@ void BrightnessDimming::NextStep() mCallback->OnChanged(mCurrentBrightness); mCallback->OnEnd(); mDimming = false; + mCondDimmingDone.notify_all(); } DISPLAY_HILOGD(FEAT_BRIGHTNESS, "animating next step, step=%{public}u, brightness=%{public}u, stride=%{public}d", mCurrentStep.load(), mCurrentBrightness.load(), mStride.load()); diff --git a/brightness_manager/src/brightness_manager.cpp b/brightness_manager/src/brightness_manager.cpp index cbac4643215cdb88cb46e4992c8b0958a8c2ab14..328815af8d1617cbca926548b27b4bdd8176e087 100644 --- a/brightness_manager/src/brightness_manager.cpp +++ b/brightness_manager/src/brightness_manager.cpp @@ -198,6 +198,15 @@ uint32_t BrightnessManager::GetDeviceBrightness() #endif } +void BrightnessManager::WaitDimmingDone() const +{ +#ifdef OHOS_BUILD_ENABLE_BRIGHTNESS_WRAPPER + mBrightnessManagerExt.WaitDimmingDone(); +#else + BrightnessService::Get().WaitDimmingDone(); +#endif +} + uint32_t BrightnessManager::SetLightBrightnessThreshold( std::vector threshold, sptr callback) { diff --git a/brightness_manager/src/brightness_manager_ext.cpp b/brightness_manager/src/brightness_manager_ext.cpp index 5d683c4ea82ad20abd0cc28d8a172d2200d29b8b..6a55bfd06f522b8de58212e6ca1d4e5b4a533094 100644 --- a/brightness_manager/src/brightness_manager_ext.cpp +++ b/brightness_manager/src/brightness_manager_ext.cpp @@ -113,6 +113,11 @@ bool BrightnessManagerExt::LoadBrightnessOpsEx1() DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym IsAutoAdjustBrightness func failed!"); return false; } + mWaitDimmingDoneFunc = dlsym(mBrightnessManagerExtHandle, "WaitDimmingDone"); + if (!mWaitDimmingDoneFunc) { + DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym WaitDimmingDone func failed!"); + return false; + } return true; } @@ -244,6 +249,7 @@ void BrightnessManagerExt::CloseBrightnessExtLibrary() mIsBrightnessBoostedFunc = nullptr; mGetBrightnessFunc = nullptr; mGetDeviceBrightnessFunc = nullptr; + mWaitDimmingDoneFunc = nullptr; mClearOffsetFunc = nullptr; mGetCurrentDisplayIdFunc = nullptr; mSetDisplayIdFunc = nullptr; @@ -406,6 +412,15 @@ uint32_t BrightnessManagerExt::GetDeviceBrightness() return getDeviceBrightnessFunc(); } +void BrightnessManagerExt::WaitDimmingDone() const +{ + if (!mBrightnessManagerExtEnable) { + return; + } + auto waitDimmingDoneFunc = reinterpret_cast(mWaitDimmingDoneFunc); + waitDimmingDoneFunc(); +} + bool BrightnessManagerExt::IsBrightnessOverridden() const { if (!mBrightnessManagerExtEnable) { diff --git a/brightness_manager/src/brightness_service.cpp b/brightness_manager/src/brightness_service.cpp index 6646573a2b17bcf5d471ca4944caa01c0ddc1909..b8651667a75520b097d2498e256b80546243d05b 100644 --- a/brightness_manager/src/brightness_service.cpp +++ b/brightness_manager/src/brightness_service.cpp @@ -789,6 +789,13 @@ uint32_t BrightnessService::GetDeviceBrightness() return GetOrigBrightnessLevel(brightness); } +void BrightnessService::WaitDimmingDone() const +{ + if (mDimming != nullptr) { + mDimming->WaitDimmingDone(); + } +} + uint32_t BrightnessService::GetCachedSettingBrightness() { return mCachedSettingBrightness; diff --git a/brightness_manager/test/unittest/src/brightness_manager_ext_test.cpp b/brightness_manager/test/unittest/src/brightness_manager_ext_test.cpp index cd7ccb08a42cbea4622f94e1b14b5bd247d4920e..1d7b018bebaab22e0e345dc74c00dfc6cb20051e 100644 --- a/brightness_manager/test/unittest/src/brightness_manager_ext_test.cpp +++ b/brightness_manager/test/unittest/src/brightness_manager_ext_test.cpp @@ -226,6 +226,7 @@ HWTEST_F(BrightnessManagerExtTest, Init, TestSize.Level1) usleep(INIT_WAITING_TIME); double discount = g_BrightnessManagerExt.GetDiscount(); EXPECT_EQ(1.0, discount); + g_BrightnessManagerExt.WaitDimmingDone(); DISPLAY_HILOGI(LABEL_TEST, "BrightnessManagerExtInit001 function end!"); } diff --git a/brightness_manager/test/unittest/src/mock_brightness_manager_interface.cpp b/brightness_manager/test/unittest/src/mock_brightness_manager_interface.cpp index 17d4046313cc848e57420e72561a1ed8d2f33b44..a7a35a2a93322714aedd230c2f851887439682f2 100644 --- a/brightness_manager/test/unittest/src/mock_brightness_manager_interface.cpp +++ b/brightness_manager/test/unittest/src/mock_brightness_manager_interface.cpp @@ -142,6 +142,10 @@ uint32_t GetDeviceBrightness() return MockReturnValue(); } +void WaitDimmingDone() +{ +} + void ClearOffset() { } @@ -193,6 +197,7 @@ void MockInitBrightnessManagerExt(OHOS::DisplayPowerMgr::BrightnessManagerExt& e ext.mIsBrightnessBoostedFunc = reinterpret_cast(IsBrightnessBoosted); ext.mGetBrightnessFunc = reinterpret_cast(GetBrightness); ext.mGetDeviceBrightnessFunc = reinterpret_cast(GetDeviceBrightness); + ext.mWaitDimmingDoneFunc = reinterpret_cast(WaitDimmingDone); ext.mClearOffsetFunc = reinterpret_cast(ClearOffset); ext.mGetCurrentDisplayIdFunc = reinterpret_cast(GetCurrentDisplayId); ext.mSetDisplayIdFunc = reinterpret_cast(SetDisplayId); diff --git a/state_manager/frameworks/native/display_power_mgr_client.cpp b/state_manager/frameworks/native/display_power_mgr_client.cpp index 4a07c9e2ee376cd0976c718989c3f53c25354a1f..0534a8274915a4d3481824b5ca447381fe74c0d8 100644 --- a/state_manager/frameworks/native/display_power_mgr_client.cpp +++ b/state_manager/frameworks/native/display_power_mgr_client.cpp @@ -371,6 +371,16 @@ uint32_t DisplayPowerMgrClient::GetDeviceBrightness(uint32_t displayId) return brightness; } +void DisplayPowerMgrClient::WaitDimmingDone() +{ + auto proxy = GetProxy(); + RETURN_IF(proxy == nullptr); + auto ret = proxy->WaitDimmingDone(); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "WaitDimmingDone, ret = %{public}d", ret); + } +} + bool DisplayPowerMgrClient::SetCoordinated(bool coordinated, uint32_t displayId) { auto proxy = GetProxy(); diff --git a/state_manager/interfaces/inner_api/native/include/display_power_mgr_client.h b/state_manager/interfaces/inner_api/native/include/display_power_mgr_client.h index aa5d0b5a7e64764ba9fa3fa10e4bc4780a981f74..c34cceaee0808db01ed4266d96702817e3922139 100644 --- a/state_manager/interfaces/inner_api/native/include/display_power_mgr_client.h +++ b/state_manager/interfaces/inner_api/native/include/display_power_mgr_client.h @@ -57,6 +57,7 @@ public: bool BoostBrightness(int32_t timeoutMs, uint32_t displayId = 0); bool CancelBoostBrightness(uint32_t displayId = 0); uint32_t GetDeviceBrightness(uint32_t displayId = 0); + void WaitDimmingDone(); bool SetCoordinated(bool coordinated, uint32_t displayId = 0); uint32_t SetLightBrightnessThreshold(std::vector threshold, sptr callback); DisplayErrors GetError(); diff --git a/state_manager/service/IDisplayPowerMgr.idl b/state_manager/service/IDisplayPowerMgr.idl index a09a1342f26d20a3a2ac460868140943731bc343..94dde39478870593f71aec717945f726010b7af0 100644 --- a/state_manager/service/IDisplayPowerMgr.idl +++ b/state_manager/service/IDisplayPowerMgr.idl @@ -19,7 +19,7 @@ interface OHOS.DisplayPowerMgr.IDisplayPowerCallback; interface OHOS.DisplayPowerMgr.IDisplayPowerMgr { [ipccode 0] void SetDisplayState([in] unsigned int id, [in] unsigned int state, [in] unsigned int reason, [out] boolean bResult); - void GetDisplayState([in] unsigned int id, [out] int displayState); + void GetDisplayState([in] unsigned int id, [out] int displayState); void GetDisplayIds([out] unsigned int[] ids); void GetMainDisplayId([out] unsigned int id); void SetBrightness([in] unsigned int value, [in] unsigned int displayId, [in] boolean continuous, @@ -50,4 +50,5 @@ interface OHOS.DisplayPowerMgr.IDisplayPowerMgr { void NotifyScreenPowerStatus([in] unsigned int displayId, [in] unsigned int displayPowerStatus, [out] int retCode); void SetScreenOnBrightness([out] boolean bResult); + void WaitDimmingDone(); } \ No newline at end of file diff --git a/state_manager/service/native/include/display_power_mgr_service.h b/state_manager/service/native/include/display_power_mgr_service.h index e2522ac67fecf49d87204ca568e9cadeea779e06..ea7df429401f736d4de89864740dd1f05d92a86e 100644 --- a/state_manager/service/native/include/display_power_mgr_service.h +++ b/state_manager/service/native/include/display_power_mgr_service.h @@ -45,36 +45,37 @@ class DisplayPowerMgrService : public DisplayPowerMgrStub { public: virtual ~DisplayPowerMgrService() = default; - int32_t SetDisplayState(uint32_t id, uint32_t state, uint32_t reason, bool& result) override; - int32_t GetDisplayState(uint32_t id, int32_t& displayState) override; - int32_t GetDisplayIds(std::vector& ids) override; - int32_t GetMainDisplayId(uint32_t& id) override; - int32_t SetBrightness(uint32_t value, uint32_t displayId, bool continuous, bool& result, + ErrCode SetDisplayState(uint32_t id, uint32_t state, uint32_t reason, bool& result) override; + ErrCode GetDisplayState(uint32_t id, int32_t& displayState) override; + ErrCode GetDisplayIds(std::vector& ids) override; + ErrCode GetMainDisplayId(uint32_t& id) override; + ErrCode SetBrightness(uint32_t value, uint32_t displayId, bool continuous, bool& result, int32_t& displayError) override; - int32_t SetMaxBrightness(double value, uint32_t mode, bool& result, int32_t& displayError) override; - int32_t SetMaxBrightnessNit(uint32_t maxNit, uint32_t mode, bool& result, int32_t& displayError) override; - int32_t DiscountBrightness(double discount, uint32_t displayId, bool& result) override; - int32_t OverrideBrightness(uint32_t value, uint32_t displayId, uint32_t duration, bool& result) override; - int32_t OverrideDisplayOffDelay(uint32_t delayMs, bool& result) override; + ErrCode SetMaxBrightness(double value, uint32_t mode, bool& result, int32_t& displayError) override; + ErrCode SetMaxBrightnessNit(uint32_t maxNit, uint32_t mode, bool& result, int32_t& displayError) override; + ErrCode DiscountBrightness(double discount, uint32_t displayId, bool& result) override; + ErrCode OverrideBrightness(uint32_t value, uint32_t displayId, uint32_t duration, bool& result) override; + ErrCode OverrideDisplayOffDelay(uint32_t delayMs, bool& result) override; - int32_t RestoreBrightness(uint32_t displayId, uint32_t duration, bool& result) override; + ErrCode RestoreBrightness(uint32_t displayId, uint32_t duration, bool& result) override; - int32_t GetBrightness(uint32_t displayId, uint32_t& brightness) override; - int32_t GetDefaultBrightness(uint32_t& defaultBrightness) override; - int32_t GetMaxBrightness(uint32_t& maxBrightness) override; - int32_t GetMinBrightness(uint32_t& minBrightness) override; - int32_t AdjustBrightness(uint32_t id, int32_t value, uint32_t duration, bool& result) override; - int32_t AutoAdjustBrightness(bool enable, bool& result) override; - int32_t IsAutoAdjustBrightness(bool& result) override; - int32_t RegisterCallback(const sptr& callback, bool& result) override; - int32_t BoostBrightness(int32_t timeoutMs, uint32_t displayId, bool& result) override; - int32_t CancelBoostBrightness(uint32_t displayId, bool& result) override; - int32_t GetDeviceBrightness(uint32_t displayId, uint32_t& deviceBrightness) override; - int32_t SetCoordinated(bool coordinated, uint32_t displayId, bool& result) override; - int32_t SetLightBrightnessThreshold(const std::vector& threshold, + ErrCode GetBrightness(uint32_t displayId, uint32_t& brightness) override; + ErrCode GetDefaultBrightness(uint32_t& defaultBrightness) override; + ErrCode GetMaxBrightness(uint32_t& maxBrightness) override; + ErrCode GetMinBrightness(uint32_t& minBrightness) override; + ErrCode AdjustBrightness(uint32_t id, int32_t value, uint32_t duration, bool& result) override; + ErrCode AutoAdjustBrightness(bool enable, bool& result) override; + ErrCode IsAutoAdjustBrightness(bool& result) override; + ErrCode RegisterCallback(const sptr& callback, bool& result) override; + ErrCode BoostBrightness(int32_t timeoutMs, uint32_t displayId, bool& result) override; + ErrCode CancelBoostBrightness(uint32_t displayId, bool& result) override; + ErrCode GetDeviceBrightness(uint32_t displayId, uint32_t& deviceBrightness) override; + ErrCode SetCoordinated(bool coordinated, uint32_t displayId, bool& result) override; + ErrCode SetLightBrightnessThreshold(const std::vector& threshold, const sptr& callback, uint32_t& result) override; - int32_t SetScreenOnBrightness(bool& result) override; - int32_t NotifyScreenPowerStatus(uint32_t displayId, uint32_t displayPowerStatus, int32_t& result) override; + ErrCode SetScreenOnBrightness(bool& result) override; + ErrCode NotifyScreenPowerStatus(uint32_t displayId, uint32_t displayPowerStatus, int32_t& result) override; + ErrCode WaitDimmingDone() override; private: bool SetDisplayStateInner(uint32_t id, DisplayState state, uint32_t reason); DisplayState GetDisplayStateInner(uint32_t id); diff --git a/state_manager/service/native/src/display_power_mgr_service.cpp b/state_manager/service/native/src/display_power_mgr_service.cpp index 7b4d929c601bcbc6a479b09728c6d2232c3d1b5d..22e915b0b9c3446d6b6027a3b9bf92ec790a5590 100644 --- a/state_manager/service/native/src/display_power_mgr_service.cpp +++ b/state_manager/service/native/src/display_power_mgr_service.cpp @@ -721,21 +721,21 @@ int DisplayPowerMgrService::NotifyScreenPowerStatusInner(uint32_t displayId, uin return BrightnessManager::Get().NotifyScreenPowerStatus(displayId, displayPowerStatus); } -int32_t DisplayPowerMgrService::SetDisplayState(uint32_t id, uint32_t state, uint32_t reason, bool& result) +ErrCode DisplayPowerMgrService::SetDisplayState(uint32_t id, uint32_t state, uint32_t reason, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::SetDisplayState"); result = SetDisplayStateInner(id, static_cast(state), reason); return ERR_OK; } -int32_t DisplayPowerMgrService::GetDisplayState(uint32_t id, int32_t& displayState) +ErrCode DisplayPowerMgrService::GetDisplayState(uint32_t id, int32_t& displayState) { DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDisplayState"); displayState = static_cast(GetDisplayStateInner(id)); return ERR_OK; } -int32_t DisplayPowerMgrService::GetDisplayIds(std::vector& ids) +ErrCode DisplayPowerMgrService::GetDisplayIds(std::vector& ids) { DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDisplayIds"); auto idsTemp = GetDisplayIdsInner(); @@ -743,14 +743,14 @@ int32_t DisplayPowerMgrService::GetDisplayIds(std::vector& ids) return ERR_OK; } -int32_t DisplayPowerMgrService::GetMainDisplayId(uint32_t& id) +ErrCode DisplayPowerMgrService::GetMainDisplayId(uint32_t& id) { DisplayXCollie displayXCollie("DisplayPowerMgrService::GetMainDisplayId"); id = GetMainDisplayIdInner(); return ERR_OK; } -int32_t DisplayPowerMgrService::SetBrightness(uint32_t value, uint32_t displayId, bool continuous, bool& result, +ErrCode DisplayPowerMgrService::SetBrightness(uint32_t value, uint32_t displayId, bool continuous, bool& result, int32_t& displayError) { DisplayXCollie displayXCollie("DisplayPowerMgrService::SetBrightness"); @@ -759,14 +759,14 @@ int32_t DisplayPowerMgrService::SetBrightness(uint32_t value, uint32_t displayId return ERR_OK; } -int32_t DisplayPowerMgrService::DiscountBrightness(double discount, uint32_t displayId, bool& result) +ErrCode DisplayPowerMgrService::DiscountBrightness(double discount, uint32_t displayId, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::DiscountBrightness"); result = DiscountBrightnessInner(discount, displayId); return ERR_OK; } -int32_t DisplayPowerMgrService::OverrideBrightness(uint32_t brightness, uint32_t displayId, uint32_t duration, +ErrCode DisplayPowerMgrService::OverrideBrightness(uint32_t brightness, uint32_t displayId, uint32_t duration, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::OverrideBrightness"); @@ -774,105 +774,105 @@ int32_t DisplayPowerMgrService::OverrideBrightness(uint32_t brightness, uint32_t return ERR_OK; } -int32_t DisplayPowerMgrService::OverrideDisplayOffDelay(uint32_t delayMs, bool& result) +ErrCode DisplayPowerMgrService::OverrideDisplayOffDelay(uint32_t delayMs, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::OverrideDisplayOffDelay"); result = OverrideDisplayOffDelayInner(delayMs); return ERR_OK; } -int32_t DisplayPowerMgrService::RestoreBrightness(uint32_t displayId, uint32_t duration, bool& result) +ErrCode DisplayPowerMgrService::RestoreBrightness(uint32_t displayId, uint32_t duration, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::GetBrightness"); result = RestoreBrightnessInner(displayId, duration); return ERR_OK; } -int32_t DisplayPowerMgrService::GetBrightness(uint32_t displayId, uint32_t& brightness) +ErrCode DisplayPowerMgrService::GetBrightness(uint32_t displayId, uint32_t& brightness) { DisplayXCollie displayXCollie("DisplayPowerMgrService::GetBrightness"); brightness = GetBrightnessInner(displayId); return ERR_OK; } -int32_t DisplayPowerMgrService::GetDefaultBrightness(uint32_t& defaultBrightness) +ErrCode DisplayPowerMgrService::GetDefaultBrightness(uint32_t& defaultBrightness) { DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDefaultBrightness"); defaultBrightness = GetDefaultBrightnessInner(); return ERR_OK; } -int32_t DisplayPowerMgrService::GetMaxBrightness(uint32_t& maxBrightness) +ErrCode DisplayPowerMgrService::GetMaxBrightness(uint32_t& maxBrightness) { DisplayXCollie displayXCollie("DisplayPowerMgrService::GetMaxBrightness"); maxBrightness = GetMaxBrightnessInner(); return ERR_OK; } -int32_t DisplayPowerMgrService::GetMinBrightness(uint32_t& minBrightness) +ErrCode DisplayPowerMgrService::GetMinBrightness(uint32_t& minBrightness) { DisplayXCollie displayXCollie("DisplayPowerMgrService::GetMinBrightness"); minBrightness = GetMinBrightnessInner(); return ERR_OK; } -int32_t DisplayPowerMgrService::AdjustBrightness(uint32_t id, int32_t value, uint32_t duration, bool& result) +ErrCode DisplayPowerMgrService::AdjustBrightness(uint32_t id, int32_t value, uint32_t duration, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::AdjustBrightness"); result = AdjustBrightnessInner(id, value, duration); return ERR_OK; } -int32_t DisplayPowerMgrService::AutoAdjustBrightness(bool enable, bool& result) +ErrCode DisplayPowerMgrService::AutoAdjustBrightness(bool enable, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::AutoAdjustBrightness"); result = AutoAdjustBrightnessInner(enable); return ERR_OK; } -int32_t DisplayPowerMgrService::IsAutoAdjustBrightness(bool& result) +ErrCode DisplayPowerMgrService::IsAutoAdjustBrightness(bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::IsAutoAdjustBrightness"); result = IsAutoAdjustBrightnessInner(); return ERR_OK; } -int32_t DisplayPowerMgrService::RegisterCallback(const sptr& callback, bool& result) +ErrCode DisplayPowerMgrService::RegisterCallback(const sptr& callback, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::RegisterCallback"); result = RegisterCallbackInner(callback); return ERR_OK; } -int32_t DisplayPowerMgrService::BoostBrightness(int32_t timeoutMs, uint32_t displayId, bool& result) +ErrCode DisplayPowerMgrService::BoostBrightness(int32_t timeoutMs, uint32_t displayId, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::BoostBrightness"); result = BoostBrightnessInner(timeoutMs, displayId); return ERR_OK; } -int32_t DisplayPowerMgrService::CancelBoostBrightness(uint32_t displayId, bool& result) +ErrCode DisplayPowerMgrService::CancelBoostBrightness(uint32_t displayId, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::CancelBoostBrightness"); result = CancelBoostBrightnessInner(displayId); return ERR_OK; } -int32_t DisplayPowerMgrService::GetDeviceBrightness(uint32_t displayId, uint32_t& deviceBrightness) +ErrCode DisplayPowerMgrService::GetDeviceBrightness(uint32_t displayId, uint32_t& deviceBrightness) { DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDeviceBrightness"); deviceBrightness = GetDeviceBrightnessInner(displayId); return ERR_OK; } -int32_t DisplayPowerMgrService::SetCoordinated(bool coordinated, uint32_t displayId, bool& result) +ErrCode DisplayPowerMgrService::SetCoordinated(bool coordinated, uint32_t displayId, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::SetCoordinated"); result = SetCoordinatedInner(coordinated, displayId); return ERR_OK; } -int32_t DisplayPowerMgrService::SetLightBrightnessThreshold(const std::vector& threshold, +ErrCode DisplayPowerMgrService::SetLightBrightnessThreshold(const std::vector& threshold, const sptr& callback, uint32_t& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::SetLightBrightnessThreshold"); @@ -880,7 +880,7 @@ int32_t DisplayPowerMgrService::SetLightBrightnessThreshold(const std::vector(IDisplayPowerMgrIpcCode::COMMAND_SET_BRIGHTNESS), data, size); + g_serviceTest.TestDisplayServiceStub( + static_cast(IDisplayPowerMgrIpcCode::COMMAND_WAIT_DIMMING_DONE), data, size); return 0; } diff --git a/state_manager/test/unittest/BUILD.gn b/state_manager/test/unittest/BUILD.gn index abd962fbca3b57b67fe5a44cdc65559ddbbc743f..3648175daab31bbbf84b1b355f4e03001c9bb12d 100644 --- a/state_manager/test/unittest/BUILD.gn +++ b/state_manager/test/unittest/BUILD.gn @@ -54,6 +54,7 @@ ohos_unittest("unittest_display_mgr_service") { cfi = true cfi_cross_dso = true debug = false + blocklist = "../cfi_blocklist.txt" } sources = [ @@ -103,6 +104,7 @@ ohos_unittest("display_service_death_test") { cfi = true cfi_cross_dso = true debug = false + blocklist = "../cfi_blocklist.txt" } sources = [ "src/display_service_death_test.cpp" ] @@ -134,6 +136,7 @@ ohos_unittest("display_mock_parcel_test") { cfi = true cfi_cross_dso = true debug = false + blocklist = "../cfi_blocklist.txt" } sources = [ @@ -165,6 +168,7 @@ ohos_unittest("display_mock_test") { cfi = true cfi_cross_dso = true debug = false + blocklist = "../cfi_blocklist.txt" } sources = [ @@ -203,6 +207,7 @@ ohos_unittest("display_mock_object_test") { cfi = true cfi_cross_dso = true debug = false + blocklist = "../cfi_blocklist.txt" } sources = [ @@ -239,6 +244,7 @@ ohos_unittest("unittest_display_service_test") { cfi = true cfi_cross_dso = true debug = false + blocklist = "../cfi_blocklist.txt" } sources = [ diff --git a/state_manager/test/unittest/include/display_manager_test_base.h b/state_manager/test/unittest/include/display_manager_test_base.h new file mode 100644 index 0000000000000000000000000000000000000000..e47ed84ea18e181669faab5eecde986c2ad37443 --- /dev/null +++ b/state_manager/test/unittest/include/display_manager_test_base.h @@ -0,0 +1,97 @@ +/* + * 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 DISPLAY_MANAGER_TEST_BASE_H +#define DISPLAY_MANAGER_TEST_BASE_H + +#include +#include +#include + +#include "gtest/gtest.h" +#include "display_log.h" + +#define DT_FAILURE_TAG "DT_FAILURE_BRIGHTNESS" + +namespace OHOS { +namespace PowerMgr { +using DisplayPowerMgr::LABEL_TEST; +using DisplayPowerMgr::DISPLAY_LABEL; + +inline void PrintTimestamp(void) +{ + auto tm = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()); + std::string formatTime = (std::ostringstream() << std::put_time(std::localtime(&tm), "%Y-%m-%d %H:%M:%S")).str(); + auto timestamp = std::chrono::duration_cast( + std::chrono::system_clock::now().time_since_epoch() + ).count(); + DISPLAY_HILOGI(LABEL_TEST, "%{public}s, BrtTimestamp:%{public}lld", formatTime.c_str(), timestamp); + std::cout << formatTime << ", BrtTimestamp:" << timestamp << std::endl; +} + +class TimestampListener : public testing::EmptyTestEventListener { +public: + void OnTestPartResult(const testing::TestPartResult &result) override + { + if (result.passed()) { + return; + } + // Also output DT test failures to hilog for easier analysis + DISPLAY_HILOGI(LABEL_TEST, "[%{public}s]\n%{public}s:%{public}d: Failure\n%{public}s\n", + DT_FAILURE_TAG, result.file_name(), result.line_number(), result.summary()); + PrintTimestamp(); + } +}; + +inline void InitBeforeTest(testing::UnitTest& instance) +{ + static bool listenerRegistered = false; + if (listenerRegistered) { + return; // Only needs to be registered once for the entire process + } + listenerRegistered = true; + instance.listeners().Append(new TimestampListener()); + std::cout << std::endl; + PrintTimestamp(); + std::cout << std::endl; +} + +class TestBase : public testing::Test { +public: + TestBase(void) + { + auto instance = testing::UnitTest::GetInstance(); + if (instance == nullptr || instance->current_test_info() == nullptr) { + return; + } + InitBeforeTest(*instance); + const testing::TestInfo *info = instance->current_test_info(); + mName = info->test_suite_name() + std::string(".") + info->name(); + mLocation = info->file() + std::string(":") + std::to_string(info->line()); + DISPLAY_HILOGI(LABEL_TEST, "%{public}s: instance created!", mName.c_str()); + } + + ~TestBase(void) + { + DISPLAY_HILOGI(LABEL_TEST, "%{public}s: instance destroyed!", mName.c_str()); + } + +protected: + std::string mName{}; + std::string mLocation{}; +}; +} // namespace PowerMgr +} // namespace OHOS +#endif // DISPLAY_MANAGER_TEST_BASE_H diff --git a/state_manager/test/unittest/src/display_power_mgr_brightness_test.cpp b/state_manager/test/unittest/src/display_power_mgr_brightness_test.cpp index 70c08b8cbf9b2b1cb59d0d91ea372ded25ff83dc..97644c6d674519ae61b50156ad1106c46d77b4d1 100644 --- a/state_manager/test/unittest/src/display_power_mgr_brightness_test.cpp +++ b/state_manager/test/unittest/src/display_power_mgr_brightness_test.cpp @@ -15,10 +15,11 @@ #include #include "display_brightness_callback_stub.h" +#include "display_log.h" +#include "display_manager_test_base.h" #include "display_power_mgr_client.h" #include "setting_provider.h" #include "system_ability_definition.h" -#include "display_log.h" #include "power_mgr_client.h" using namespace testing; @@ -32,10 +33,11 @@ const double NO_DISCOUNT = 1.00; const uint32_t MAX_DEFAULT_BRIGHTNESS_LEVEL = 255; const uint32_t TEST_MODE = 1; const uint32_t NORMAL_MODE = 2; -const uint32_t DEFAULT_WAITING_TIME = 1200000; +constexpr int32_t CMD_EXECUTION_DELAY = 15 * 1000; // 15s delay before executing command +constexpr int32_t SET_AUTO_DELAY = 50 * 1000; // for datashare callback } -class DisplayPowerMgrBrightnessTest : public Test { +class DisplayPowerMgrBrightnessTest : public OHOS::PowerMgr::TestBase { public: void SetUp() { @@ -43,23 +45,35 @@ public: DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(false); DisplayPowerMgrClient::GetInstance().DiscountBrightness(NO_DISCOUNT); uint32_t maxBrightness = DisplayPowerMgrClient::GetInstance().GetMaxBrightness(); - DisplayPowerMgrClient::GetInstance().SetMaxBrightness((double)maxBrightness / MAX_DEFAULT_BRIGHTNESS_LEVEL, - TEST_MODE); + double value = (double)maxBrightness / MAX_DEFAULT_BRIGHTNESS_LEVEL; + DisplayPowerMgrClient::GetInstance().SetMaxBrightness(value, TEST_MODE); auto& powerMgrClient = PowerMgr::PowerMgrClient::GetInstance(); PowerMgr::PowerMode mode = powerMgrClient.GetDeviceMode(); if (mode == PowerMgr::PowerMode::POWER_SAVE_MODE || mode == PowerMgr::PowerMode::EXTREME_POWER_SAVE_MODE) { powerMgrClient.SetDeviceMode(PowerMgr::PowerMode::NORMAL_MODE); } + + WaitDimmingDone(); + DISPLAY_HILOGI(LABEL_TEST, "%{public}s: function start!", mName.c_str()); } void TearDown() { + WaitDimmingDone(); + DISPLAY_HILOGI(LABEL_TEST, "%{public}s: function end!", mName.c_str()); DisplayPowerMgrClient::GetInstance().RestoreBrightness(); DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); uint32_t maxBrightness = DisplayPowerMgrClient::GetInstance().GetMaxBrightness(); - DisplayPowerMgrClient::GetInstance().SetMaxBrightness((double)maxBrightness / MAX_DEFAULT_BRIGHTNESS_LEVEL, - NORMAL_MODE); + double value = (double)maxBrightness / MAX_DEFAULT_BRIGHTNESS_LEVEL; + DisplayPowerMgrClient::GetInstance().SetMaxBrightness(value, NORMAL_MODE); + } + + void WaitDimmingDone() + { + usleep(CMD_EXECUTION_DELAY); + DisplayPowerMgrClient::GetInstance().WaitDimmingDone(); + usleep(SET_AUTO_DELAY); } }; @@ -71,15 +85,12 @@ namespace { */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetBrightness001, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetBrightness001 function start!"); const uint32_t SET_BRIGHTNESS = 90; bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); EXPECT_TRUE(ret); - const int sleepTime = DEFAULT_WAITING_TIME; - usleep(sleepTime); + WaitDimmingDone(); uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(deviceBrightness, SET_BRIGHTNESS); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetBrightness001 function end!"); } /** @@ -89,15 +100,12 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetBrightness001, TestSiz */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSettingBrightness001, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSettingBrightness001 function start!"); const uint32_t SET_BRIGHTNESS_VALUE = 223; bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS_VALUE); EXPECT_TRUE(ret); - const int sleepTime = DEFAULT_WAITING_TIME; - usleep(sleepTime); // sleep 100ms, wait for setting update + WaitDimmingDone(); // wait for setting update uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); EXPECT_EQ(brightness, SET_BRIGHTNESS_VALUE); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSettingBrightness001 function end!"); } /** @@ -108,18 +116,15 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSettingBrightness001, Tes */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessNormal, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessNormal function start!"); const uint32_t SET_BRIGHTNESS = 91; - const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness + usleep(CMD_EXECUTION_DELAY); const double DISCOUNT_NORMAL = 0.8; bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_NORMAL); EXPECT_TRUE(ret); - + WaitDimmingDone(); // wait for setBrightness uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, static_cast(SET_BRIGHTNESS * DISCOUNT_NORMAL)); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessNormal function end!"); } /** @@ -130,12 +135,11 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessNormal, */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessScreenOff, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessScreenOff function start!"); DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF); + usleep(CMD_EXECUTION_DELAY); const double DISCOUNT_VALUE = 0.7; bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_VALUE); EXPECT_FALSE(ret); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessScreenOff function end!"); } /** @@ -146,18 +150,16 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessScreenO */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessBoundary001, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessBoundary001 function start!"); const uint32_t SET_BRIGHTNESS = 92; DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - usleep(DEFAULT_WAITING_TIME); + usleep(CMD_EXECUTION_DELAY); const double DISCOUNT_LOWER_BOUNDARY = 0.01; bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_LOWER_BOUNDARY); EXPECT_TRUE(ret); - + WaitDimmingDone(); uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); uint32_t minBrightness = DisplayPowerMgrClient::GetInstance().GetMinBrightness(); EXPECT_EQ(value, minBrightness); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessBoundary001 function end!"); } /** @@ -168,18 +170,15 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessBoundar */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessBoundary002, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessBoundary002 function start!"); const uint32_t SET_BRIGHTNESS = 93; - const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness + usleep(CMD_EXECUTION_DELAY); const double DISCOUNT_UPPER_BOUNDARY = 1.0; bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_UPPER_BOUNDARY); EXPECT_TRUE(ret); - + WaitDimmingDone(); uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, static_cast(SET_BRIGHTNESS * DISCOUNT_UPPER_BOUNDARY)); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessBoundary002 function end!"); } /** @@ -190,18 +189,16 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessBoundar */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessAbnormal001, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessAbnormal001 function start!"); const uint32_t SET_BRIGHTNESS = 94; DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - usleep(DEFAULT_WAITING_TIME); + usleep(CMD_EXECUTION_DELAY); const double DISCOUNT_BEYOND_LOWER_BOUNDARY = 0.0; bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_BEYOND_LOWER_BOUNDARY); EXPECT_TRUE(ret); - + WaitDimmingDone(); uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); uint32_t minBrightness = DisplayPowerMgrClient::GetInstance().GetMinBrightness(); EXPECT_EQ(value, minBrightness); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessAbnormal001 function end!"); } /** @@ -212,19 +209,16 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessAbnorma */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessAbnormal002, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessAbnormal002 function start!"); const uint32_t SET_BRIGHTNESS = 95; - const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness + usleep(CMD_EXECUTION_DELAY); const double DISCOUNT_BEYOND_UPPER_BOUNDARY = 2.0; bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_BEYOND_UPPER_BOUNDARY); EXPECT_TRUE(ret); - + WaitDimmingDone(); uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); const double DISCOUNT_MAX_VALUE = 1.0; EXPECT_EQ(value, static_cast(SET_BRIGHTNESS * DISCOUNT_MAX_VALUE)); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessAbnormal002 function end!"); } /** @@ -235,18 +229,16 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessAbnorma */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessAbnormal003, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessAbnormal003 function start!"); const uint32_t SET_BRIGHTNESS = 96; DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - usleep(DEFAULT_WAITING_TIME); + usleep(CMD_EXECUTION_DELAY); const double DISCOUNT_NEGATIVE_VALUE = -1.0; bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_NEGATIVE_VALUE); EXPECT_TRUE(ret); - + WaitDimmingDone(); uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); uint32_t minBrightness = DisplayPowerMgrClient::GetInstance().GetMinBrightness(); EXPECT_EQ(value, minBrightness); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessAbnormal003 function end!"); } /** @@ -257,29 +249,26 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessAbnorma */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness001, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness001 function start!"); const uint32_t SET_BRIGHTNESS = 97; - const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness + usleep(CMD_EXECUTION_DELAY); const double DISCOUNT_VALUE = 0.7; bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_VALUE); EXPECT_TRUE(ret); - + WaitDimmingDone(); uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * SET_BRIGHTNESS)); const uint32_t SET_OVERRIDE_BRIGHTNESS = 202; DisplayPowerMgrClient::GetInstance().OverrideBrightness(SET_OVERRIDE_BRIGHTNESS); - usleep(DEFAULT_WAITING_TIME); + WaitDimmingDone(); value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * SET_OVERRIDE_BRIGHTNESS)); DisplayPowerMgrClient::GetInstance().RestoreBrightness(); - usleep(DEFAULT_WAITING_TIME); + WaitDimmingDone(); value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * SET_BRIGHTNESS)); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness001 function end!"); } /** @@ -290,27 +279,25 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness001, Te */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness002, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness002 function start!"); const uint32_t SET_BRIGHTNESS = 150; DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; - usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness + usleep(CMD_EXECUTION_DELAY); const uint32_t SET_OVERRIDE_BRIGHTNESS = 202; DisplayPowerMgrClient::GetInstance().OverrideBrightness(SET_OVERRIDE_BRIGHTNESS); + usleep(CMD_EXECUTION_DELAY); const double DISCOUNT_VALUE = 0.7; double ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_VALUE); EXPECT_TRUE(ret); + WaitDimmingDone(); uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_TRUE(value <= static_cast(DISCOUNT_VALUE * SET_OVERRIDE_BRIGHTNESS)); ret = DisplayPowerMgrClient::GetInstance().RestoreBrightness(); - usleep(DEFAULT_WAITING_TIME); EXPECT_TRUE(ret); - + WaitDimmingDone(); value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * SET_BRIGHTNESS)); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness002 function end!"); } /** @@ -321,27 +308,25 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness002, Te */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness003, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness003 function start!"); const uint32_t SET_BRIGHTNESS = 99; DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; - usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness + usleep(CMD_EXECUTION_DELAY); const uint32_t SET_BOOST_BRIGHTNESS_TIME = 10000; DisplayPowerMgrClient::GetInstance().BoostBrightness(SET_BOOST_BRIGHTNESS_TIME); + usleep(CMD_EXECUTION_DELAY); const double DISCOUNT_VALUE = 0.7; bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_VALUE); EXPECT_TRUE(ret); - + WaitDimmingDone(); uint32_t maxBrightness = DisplayPowerMgrClient::GetInstance().GetMaxBrightness(); uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * maxBrightness)); DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); - + WaitDimmingDone(); value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * SET_BRIGHTNESS)); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness003 function end!"); } /** @@ -352,26 +337,25 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness003, Te */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness004, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness004 function start!"); const uint32_t SET_BRIGHTNESS = 100; DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; - usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness + usleep(CMD_EXECUTION_DELAY); const double DISCOUNT_VALUE = 0.7; bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_VALUE); EXPECT_TRUE(ret); + usleep(CMD_EXECUTION_DELAY); const uint32_t SET_BOOST_BRIGHTNESS_TIME = 10000; DisplayPowerMgrClient::GetInstance().BoostBrightness(SET_BOOST_BRIGHTNESS_TIME); + WaitDimmingDone(); uint32_t maxBrightness = DisplayPowerMgrClient::GetInstance().GetMaxBrightness(); uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * maxBrightness)); DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); - + WaitDimmingDone(); value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * SET_BRIGHTNESS)); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness004 function end!"); } /** @@ -382,18 +366,15 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness004, Te */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness005, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness005 function start!"); const uint32_t SET_BRIGHTNESS = 103; DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - usleep(DEFAULT_WAITING_TIME); + usleep(CMD_EXECUTION_DELAY); const double DISCOUNT_VALUE = 0.7; bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_VALUE); EXPECT_TRUE(ret); - const int sleepTime = 100000; - usleep(sleepTime); // sleep 100ms, wait for setting update + usleep(CMD_EXECUTION_DELAY); uint32_t beforeBrightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); EXPECT_EQ(SET_BRIGHTNESS, beforeBrightness); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness005 function end!"); } /** @@ -403,16 +384,13 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness005, Te */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness001, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness001 function start!"); const uint32_t OVERRIDE_BRIGHTNESS = 255; bool ret = DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BRIGHTNESS); - usleep(DEFAULT_WAITING_TIME); EXPECT_TRUE(ret); + WaitDimmingDone(); uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, OVERRIDE_BRIGHTNESS); DisplayPowerMgrClient::GetInstance().RestoreBrightness(); - usleep(DEFAULT_WAITING_TIME); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness001 function end!"); } /** @@ -422,24 +400,21 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness001, Te */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness002, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness002 function start!"); const uint32_t SET_BRIGHTNESS = 104; const uint32_t OVERRIDE_BRIGHTNESS = 255; - const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness EXPECT_TRUE(ret); + usleep(CMD_EXECUTION_DELAY); ret = DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BRIGHTNESS); - usleep(DEFAULT_WAITING_TIME); EXPECT_TRUE(ret); + WaitDimmingDone(); uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, OVERRIDE_BRIGHTNESS); ret = DisplayPowerMgrClient::GetInstance().RestoreBrightness(); // restore - usleep(DEFAULT_WAITING_TIME); EXPECT_TRUE(ret); + WaitDimmingDone(); value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, SET_BRIGHTNESS); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness002 function end!"); } /** @@ -449,20 +424,17 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness002, Te */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness003, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness003 function start!"); const uint32_t SET_BRIGHTNESS = 105; const uint32_t OVERRIDE_BRIGHTNESS = 255; bool ret = DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BRIGHTNESS); - usleep(DEFAULT_WAITING_TIME); EXPECT_TRUE(ret); + usleep(CMD_EXECUTION_DELAY); ret = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - usleep(DEFAULT_WAITING_TIME); EXPECT_FALSE(ret); + WaitDimmingDone(); uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, OVERRIDE_BRIGHTNESS); DisplayPowerMgrClient::GetInstance().RestoreBrightness(); - usleep(DEFAULT_WAITING_TIME); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness003 function end!"); } /** @@ -472,16 +444,15 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness003, Te */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness004, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness004 function start!"); const uint32_t SET_BRIGHTNESS = 106; bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - usleep(DEFAULT_WAITING_TIME); + usleep(CMD_EXECUTION_DELAY); EXPECT_TRUE(ret); ret = DisplayPowerMgrClient::GetInstance().RestoreBrightness(); EXPECT_FALSE(ret); + WaitDimmingDone(); uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, SET_BRIGHTNESS); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness004 function end!"); } /** @@ -491,14 +462,14 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness004, Te */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness005, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness005 function start!"); DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF); + usleep(CMD_EXECUTION_DELAY); const uint32_t OVERRIDE_BRIGHTNESS = 100; bool isBoost = DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BRIGHTNESS); EXPECT_FALSE(isBoost); + usleep(CMD_EXECUTION_DELAY); bool isRestore = DisplayPowerMgrClient::GetInstance().RestoreBrightness(); EXPECT_FALSE(isRestore); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness005 function end!"); } /** @@ -509,14 +480,12 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness005, Te */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness006, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness006 function start!"); uint32_t overrideValue = 256; uint32_t brightnessMax = 255; DisplayPowerMgrClient::GetInstance().OverrideBrightness(overrideValue); - usleep(DEFAULT_WAITING_TIME); + WaitDimmingDone(); uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(brightnessMax, deviceBrightness); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness006 function end!"); } /** @@ -527,16 +496,13 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness006, Te */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness007, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness007 function start!"); uint32_t overrideValue = 0; uint32_t brightnessMin = DisplayPowerMgrClient::GetInstance().GetMinBrightness(); EXPECT_TRUE(DisplayPowerMgrClient::GetInstance().OverrideBrightness(overrideValue)); - usleep(DEFAULT_WAITING_TIME); + WaitDimmingDone(); uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(brightnessMin, deviceBrightness); DisplayPowerMgrClient::GetInstance().RestoreBrightness(); - usleep(DEFAULT_WAITING_TIME); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness007 function end!"); } /** @@ -547,16 +513,13 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness007, Te */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness008, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness008 function start!"); uint32_t overrideValue = -1; uint32_t brightnessMax = 255; EXPECT_TRUE(DisplayPowerMgrClient::GetInstance().OverrideBrightness(overrideValue)); - usleep(DEFAULT_WAITING_TIME); + WaitDimmingDone(); uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(brightnessMax, deviceBrightness); DisplayPowerMgrClient::GetInstance().RestoreBrightness(); - usleep(DEFAULT_WAITING_TIME); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness008 function end!"); } /** @@ -568,23 +531,21 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness008, Te */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness009, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness009 function start!"); const uint32_t OVERRIDE_BRIGHTNESS = 156; const uint32_t SET_BRIGHTNESS = 66; auto currentBrightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); bool ret1 = DisplayPowerMgrClient::GetInstance().SetBrightness(currentBrightness); - usleep(DEFAULT_WAITING_TIME); EXPECT_TRUE(ret1); + usleep(CMD_EXECUTION_DELAY); DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BRIGHTNESS); - usleep(DEFAULT_WAITING_TIME); + usleep(CMD_EXECUTION_DELAY); bool ret2 = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - usleep(DEFAULT_WAITING_TIME); EXPECT_FALSE(ret2); + usleep(CMD_EXECUTION_DELAY); DisplayPowerMgrClient::GetInstance().RestoreBrightness(); - usleep(DEFAULT_WAITING_TIME); + WaitDimmingDone(); uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(currentBrightness, deviceBrightness); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness009 function end!"); } /** @@ -594,15 +555,13 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness009, Te */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrMaxBrightness001, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrMaxBrightness001 function start!"); uint32_t max = DisplayPowerMgrClient::GetInstance().GetMaxBrightness(); EXPECT_LE(max, 255); bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(max + 100); - usleep(DEFAULT_WAITING_TIME); // sleep 100ms, wait for setting update EXPECT_TRUE(ret); + WaitDimmingDone(); // wait for setting update uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, max); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrMaxBrightness001 function end!"); } /** @@ -612,16 +571,14 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrMaxBrightness001, TestSiz */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrMinBrightness001, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrMinBrightness001 function start!"); const uint32_t SET_BRIGHTNESS_VALUE = 0; uint32_t min = DisplayPowerMgrClient::GetInstance().GetMinBrightness(); EXPECT_GE(min, 0); bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS_VALUE); - usleep(DEFAULT_WAITING_TIME); // sleep 100ms, wait for setting update EXPECT_TRUE(ret); + WaitDimmingDone(); // wait for setting update uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, min); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrMinBrightness001 function end!"); } /** @@ -631,11 +588,9 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrMinBrightness001, TestSiz */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDefaultBrightness001, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDefaultBrightness001 function start!"); uint32_t value = DisplayPowerMgrClient::GetInstance().GetDefaultBrightness(); EXPECT_GE(value, 0); EXPECT_LE(value, 255); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDefaultBrightness001 function end!"); } /** @@ -645,11 +600,9 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDefaultBrightness001, Tes */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessNormal, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessNormal function start!"); const uint32_t BOOST_TIME = 100; // keep BoostBrightness 100ms bool isSucc = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_TIME); EXPECT_TRUE(isSucc); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessNormal function end!"); } /** @@ -659,11 +612,9 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessNormal, Te */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessAbnormal, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessAbnormal function start!"); const uint32_t BOOST_TIME = -1; bool isSucc = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_TIME); EXPECT_FALSE(isSucc); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessAbnormal function end!"); } /** @@ -673,13 +624,12 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessAbnormal, */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrCancelBoostBrightnessNormal, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrCancelBoostBrightnessNormal function start!"); const uint32_t BOOST_TIME = 50000; bool isSucc = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_TIME); EXPECT_TRUE(isSucc); + usleep(CMD_EXECUTION_DELAY); bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); EXPECT_TRUE(isCancel); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrCancelBoostBrightnessNormal function end!"); } /** @@ -689,16 +639,16 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrCancelBoostBrightnessNorm */ HWTEST_F(DisplayPowerMgrBrightnessTest, BoostAndOverrideMutuallyExclusive1, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "BoostAndOverrideMutuallyExclusive function start!"); const uint32_t BOOST_TIME = 50000; const uint32_t OVERRIDE_BIRGHTNESS = 100; bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_TIME); EXPECT_TRUE(isBoost); + usleep(CMD_EXECUTION_DELAY); bool isOverride = DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BIRGHTNESS); EXPECT_FALSE(isOverride); + usleep(CMD_EXECUTION_DELAY); bool isRestore = DisplayPowerMgrClient::GetInstance().RestoreBrightness(); EXPECT_FALSE(isRestore); - DISPLAY_HILOGI(LABEL_TEST, "BoostAndOverrideMutuallyExclusive function end!"); } /** @@ -708,18 +658,18 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, BoostAndOverrideMutuallyExclusive1, Test */ HWTEST_F(DisplayPowerMgrBrightnessTest, BoostAndOverrideMutuallyExclusive2, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "BoostAndOverrideMutuallyExclusive2 function start!"); const uint32_t BOOST_TIME = 50000; const uint32_t OVERRIDE_BIRGHTNESS = 255; bool isOverride = DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BIRGHTNESS); EXPECT_TRUE(isOverride); + usleep(CMD_EXECUTION_DELAY); bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_TIME); EXPECT_FALSE(isBoost); + usleep(CMD_EXECUTION_DELAY); bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); EXPECT_FALSE(isCancel); + usleep(CMD_EXECUTION_DELAY); DisplayPowerMgrClient::GetInstance().RestoreBrightness(); - usleep(DEFAULT_WAITING_TIME); - DISPLAY_HILOGI(LABEL_TEST, "BoostAndOverrideMutuallyExclusive2 function end!"); } /** @@ -729,16 +679,15 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, BoostAndOverrideMutuallyExclusive2, Test */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessTimeout1, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessTimeout1 function start!"); uint32_t beforeValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); const uint32_t BOOST_BRIGHTNESS_TIME = 100; bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); EXPECT_TRUE(isBoost); - const int sleepTime = 200000; - usleep(sleepTime); // sleep 200ms, wait for setting update + const int sleepTime = (BOOST_BRIGHTNESS_TIME + 50) * 1000; // wait for BoostBrightness timeout + usleep(sleepTime); + WaitDimmingDone(); uint32_t currentValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(beforeValue, currentValue); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessTimeout1 function end!"); } /** @@ -748,19 +697,17 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessTimeout1, */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessTimeout2, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessTimeout2 function start!"); const uint32_t SET_BRIGHTNESS = 106; const uint32_t BOOST_BRIGHTNESS_TIME = 100; - const int sleepTime = (BOOST_BRIGHTNESS_TIME + 50) * 1000; // wait for (100 + 50)ms BoostBrightness timeout bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); EXPECT_TRUE(isBoost); - usleep(sleepTime); // sleep 100ms, wait for cancel BoostBrightness + const int sleepTime = (BOOST_BRIGHTNESS_TIME + 50) * 1000; // wait for BoostBrightness timeout + usleep(sleepTime); bool isSet = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - usleep(DEFAULT_WAITING_TIME); // sleep 100ms, wait for setting update EXPECT_TRUE(isSet); + WaitDimmingDone(); uint32_t currentValue = DisplayPowerMgrClient::GetInstance().GetBrightness(); EXPECT_EQ(SET_BRIGHTNESS, currentValue); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessTimeout2 function end!"); } /** @@ -770,23 +717,19 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessTimeout2, */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessCancel1, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessCancel1 function start!"); const uint32_t SET_BRIGHTNESS = 106; DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - const int32_t SET_SLEEP_TIME = DEFAULT_WAITING_TIME; - usleep(SET_SLEEP_TIME); // sleep 200ms, wait for setBrightness + usleep(CMD_EXECUTION_DELAY); const uint32_t BOOST_BRIGHTNESS_TIME = 10000; - const int SLEEP_TIME = 100000; bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); EXPECT_TRUE(isBoost); + usleep(CMD_EXECUTION_DELAY); bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); EXPECT_TRUE(isCancel); - usleep(SLEEP_TIME); // sleep 100ms, wait for cancel BoostBrightness + WaitDimmingDone(); uint32_t currentValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(SET_BRIGHTNESS, currentValue) << "beforeValue: " << SET_BRIGHTNESS << " currentVal: " << currentValue; - DISPLAY_HILOGI(LABEL_TEST, "BoostBrightnessCancel1: beforeValue: %{public}d, currentVal: %{public}d", - SET_BRIGHTNESS, currentValue); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessCancel1 function end!"); + DISPLAY_HILOGI(LABEL_TEST, "beforeValue: %{public}d, currentVal: %{public}d", SET_BRIGHTNESS, currentValue); } /** @@ -796,19 +739,19 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessCancel1, T */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessCancel2, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessCancel2 function start!"); const uint32_t BOOST_BRIGHTNESS_TIME = 10000; bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); EXPECT_TRUE(isBoost); + usleep(CMD_EXECUTION_DELAY); bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); EXPECT_TRUE(isCancel); + usleep(CMD_EXECUTION_DELAY); const uint32_t SET_BRIGHTNESS_VALUE = 111; bool isSet = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS_VALUE); - usleep(DEFAULT_WAITING_TIME); // sleep 100ms, wait for setting update EXPECT_TRUE(isSet); + WaitDimmingDone(); uint32_t currentValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(SET_BRIGHTNESS_VALUE, currentValue); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessCancel2 function end!"); } /** @@ -818,20 +761,20 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessCancel2, T */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessNotAdjust, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessNotAdjust function start!"); const uint32_t SET_BRIGHTNESS = 107; const uint32_t BOOST_BRIGHTNESS_TIME = 10000; DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - usleep(DEFAULT_WAITING_TIME); + usleep(CMD_EXECUTION_DELAY); bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); EXPECT_TRUE(isBoost); + usleep(CMD_EXECUTION_DELAY); bool isSet = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - usleep(DEFAULT_WAITING_TIME); EXPECT_FALSE(isSet); + usleep(CMD_EXECUTION_DELAY); DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); + WaitDimmingDone(); uint32_t currentValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(SET_BRIGHTNESS, currentValue); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessNotAdjust function end!"); } /** @@ -841,14 +784,14 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessNotAdjust, */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessScreenOff, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessScreenOff function start!"); DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF); + usleep(CMD_EXECUTION_DELAY); const uint32_t BOOST_BRIGHTNESS_TIME = 10000; bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); EXPECT_FALSE(isBoost); + usleep(CMD_EXECUTION_DELAY); bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); EXPECT_FALSE(isCancel); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessScreenOff function end!"); } /** @@ -858,31 +801,28 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessScreenOff, */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessMultipleCalls, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessMultipleCalls function start!"); const uint32_t SET_BRIGHTNESS = 108; const uint32_t COUNT = 3; const uint32_t TIMEOUT = 100; - const uint32_t SLEEP_TIME = DEFAULT_WAITING_TIME; - const uint32_t UPDATE_TIME = 20000; for (uint32_t i = 0; i < COUNT; ++i) { bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(TIMEOUT); - usleep(UPDATE_TIME); // wait for set newest BoostBrightness time EXPECT_TRUE(isBoost); + usleep(CMD_EXECUTION_DELAY); } // Brightness adjustment is not allowed bool isSet = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); EXPECT_FALSE(isSet); - // Wait for a timeout - usleep(SLEEP_TIME); + const int sleepTime = TIMEOUT * 1000; // wait for BoostBrightness timeout + usleep(sleepTime); bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); EXPECT_FALSE(isCancel); + usleep(CMD_EXECUTION_DELAY); const uint32_t SET_BRIGHTNESS_VALUE = 222; isSet = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS_VALUE); - usleep(DEFAULT_WAITING_TIME); EXPECT_TRUE(isSet); + WaitDimmingDone(); uint32_t currentVal = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(SET_BRIGHTNESS_VALUE, currentVal); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessMultipleCalls function end!"); } /** @@ -892,12 +832,9 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessMultipleCa */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrAdjustBrightness001, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness001 function start!"); bool ret = DisplayPowerMgrClient::GetInstance().AdjustBrightness(0, 3000); EXPECT_TRUE(ret); DisplayPowerMgrClient::GetInstance().AdjustBrightness(0, 5); - usleep(10000); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness001 function end!"); } /** @@ -907,21 +844,17 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrAdjustBrightness001, Test */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrAdjustBrightness002, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness002 function start!"); bool ret = DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(true); - //waiting to find correct isSettingEnable value - usleep(50000); + usleep(SET_AUTO_DELAY); // waiting to find correct isSettingEnable value if (ret) { DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness002: is supported"); ret = DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(false); - //waiting to find correct isSettingEnable value - usleep(50000); EXPECT_TRUE(ret); + usleep(SET_AUTO_DELAY); } else { DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness002: is not supported"); EXPECT_FALSE(ret); } - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness002 function end!"); } /** @@ -932,16 +865,11 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrAdjustBrightness002, Test */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrAdjustBrightness003, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness003 function start!"); bool ret = DisplayPowerMgrClient::GetInstance().IsAutoAdjustBrightness(); DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(false); - //waiting to find correct isSettingEnable value - usleep(50000); + usleep(SET_AUTO_DELAY); EXPECT_EQ(DisplayPowerMgrClient::GetInstance().IsAutoAdjustBrightness(), false); DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(ret); - //waiting to find correct isSettingEnable value - usleep(50000); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness003 function end!"); } /** @@ -952,21 +880,19 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrAdjustBrightness003, Test */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrScreenBrightnessEquality001, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrScreenBrightnessEquality001 function start!"); DisplayPowerMgrClient::GetInstance().AdjustBrightness(0, 5); - usleep(10000); + usleep(SET_AUTO_DELAY); + WaitDimmingDone(); uint32_t deviceBrightness1 = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF); DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(true); - //waiting to find correct isSettingEnable value - usleep(50000); + usleep(SET_AUTO_DELAY); DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(false); - //waiting to find correct isSettingEnable value - usleep(50000); + usleep(SET_AUTO_DELAY); DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON); + WaitDimmingDone(); uint32_t deviceBrightness2 = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(deviceBrightness1, deviceBrightness2); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrScreenBrightnessEquality001 function end!"); } /** @@ -977,15 +903,12 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrScreenBrightnessEquality0 */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSleepBrightness001, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSleepBrightness001 function start!"); uint32_t deviceBrightness1 = DisplayPowerMgrClient::GetInstance().GetBrightness(); DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_DIM); - //waiting to find correct isSettingEnable value - usleep(50000); + WaitDimmingDone(); uint32_t deviceBrightness2 = DisplayPowerMgrClient::GetInstance().GetBrightness(); EXPECT_EQ(deviceBrightness1, deviceBrightness2); DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSleepBrightness001 function end!"); } /** @@ -996,7 +919,6 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSleepBrightness001, TestS */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetLightBrightnessThreshold001, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetLightBrightnessThreshold001 function start!"); std::vector threshold = {200, 200, 20}; uint32_t type = 1; int32_t state = 0; @@ -1005,7 +927,6 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetLightBrightnessThresho callback->OnNotifyApsLightBrightnessChange(type, state); uint32_t result = DisplayPowerMgrClient::GetInstance().SetLightBrightnessThreshold(threshold, callback); EXPECT_EQ(result, SUCCESS_RESULT); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetLightBrightnessThreshold001 function end!"); } /** @@ -1016,7 +937,6 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetLightBrightnessThresho */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetLightBrightnessThreshold002, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetLightBrightnessThreshold002 function start!"); std::vector threshold = {}; uint32_t type = 1; int32_t state = 0; @@ -1025,7 +945,6 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetLightBrightnessThresho callback->OnNotifyApsLightBrightnessChange(type, state); uint32_t result = DisplayPowerMgrClient::GetInstance().SetLightBrightnessThreshold(threshold, callback); EXPECT_EQ(result, FAILD_RESULT); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetLightBrightnessThreshold002 function end!"); } /** @@ -1036,23 +955,19 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetLightBrightnessThresho */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightnessNit001, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightnessNit001 function start!"); const uint32_t SET_BRIGHTNESS = 150; // mapping nit = 350 const uint32_t SET_BRIGHTNESS_NIT = 350; DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; - usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness + usleep(CMD_EXECUTION_DELAY); const uint32_t SET_MAX_BRIGHTNESS = 98; // mapping nit = 231 const uint32_t SET_MAX_BRIGHTNESS_NIT = 231; bool ret = DisplayPowerMgrClient::GetInstance().SetMaxBrightnessNit(SET_MAX_BRIGHTNESS_NIT, 2); EXPECT_TRUE(ret); - const int32_t SLEEP_TIME_BRIGHTNESS = 10000000; - usleep(SLEEP_TIME_BRIGHTNESS); // sleep 10s, wait for setBrightness + WaitDimmingDone(); uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); EXPECT_EQ(SET_MAX_BRIGHTNESS, brightness); DisplayPowerMgrClient::GetInstance().SetMaxBrightnessNit(SET_BRIGHTNESS_NIT, 1); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightnessNit001 function end!"); } /** @@ -1062,22 +977,18 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightnessNit001, T */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightnessNit002, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightnessNit002 function start!"); const uint32_t SET_BRIGHTNESS = 150; // mapping nit = 350 const uint32_t SET_BRIGHTNESS_NIT = 350; DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; - usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness + usleep(CMD_EXECUTION_DELAY); const uint32_t SET_MAX_BRIGHTNESS_NIT = 469; // mapping level = 200; bool ret = DisplayPowerMgrClient::GetInstance().SetMaxBrightnessNit(SET_MAX_BRIGHTNESS_NIT, 2); EXPECT_TRUE(ret); - const int32_t SLEEP_TIME_BRIGHTNESS = 10000000; - usleep(SLEEP_TIME_BRIGHTNESS); // sleep 10s, wait for setBrightness + WaitDimmingDone(); uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); EXPECT_EQ(SET_BRIGHTNESS, brightness); DisplayPowerMgrClient::GetInstance().SetMaxBrightnessNit(SET_BRIGHTNESS_NIT, 1); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightnessNit002 function end!"); } /** @@ -1088,22 +999,17 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightnessNit002, T */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightness001, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightness001 function start!"); const uint32_t SET_BRIGHTNESS = 150; DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; - usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness + usleep(CMD_EXECUTION_DELAY); const uint32_t SET_MAX_BRIGHTNESS = 98; bool ret = DisplayPowerMgrClient::GetInstance().SetMaxBrightness((double)SET_MAX_BRIGHTNESS / 255, 2); EXPECT_TRUE(ret); - const int32_t SLEEP_TIME_BRIGHTNESS = 10000000; - usleep(SLEEP_TIME_BRIGHTNESS); // sleep 10s, wait for setBrightness + WaitDimmingDone(); uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); EXPECT_EQ(SET_MAX_BRIGHTNESS, brightness); DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS, 1); - usleep(SLEEP_TIME); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightness001 function end!"); } /** @@ -1113,21 +1019,17 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightness001, Test */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightness002, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightness002 function start!"); const uint32_t SET_BRIGHTNESS = 150; DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); - const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; - usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness + usleep(CMD_EXECUTION_DELAY); const uint32_t SET_MAX_BRIGHTNESS = 200; bool ret = DisplayPowerMgrClient::GetInstance().SetMaxBrightness((double)SET_MAX_BRIGHTNESS / 255, 2); EXPECT_TRUE(ret); - const int32_t SLEEP_TIME_BRIGHTNESS = 10000000; - usleep(SLEEP_TIME_BRIGHTNESS); // sleep 10s, wait for setBrightness + WaitDimmingDone(); uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); EXPECT_EQ(SET_BRIGHTNESS, brightness); DisplayPowerMgrClient::GetInstance().SetMaxBrightness(SET_BRIGHTNESS, 1); - DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightness002 function end!"); } /** @@ -1138,14 +1040,12 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightness002, Test */ HWTEST_F(DisplayPowerMgrBrightnessTest, NotifyBrightnessManagerScreenPowerStatus001, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "NotifyBrightnessManagerScreenPowerStatus001 function start!"); uint32_t displayId = 0; uint32_t screenPowerStatus = 0; // 0 represent the POWER_STATUS_ON uint32_t result = DisplayPowerMgrClient::GetInstance().NotifyBrightnessManagerScreenPowerStatus(displayId, screenPowerStatus); const uint32_t FAILED_RESULT = 0; EXPECT_EQ(result, FAILED_RESULT); - DISPLAY_HILOGI(LABEL_TEST, "NotifyBrightnessManagerScreenPowerStatus001 function end!"); } /** @@ -1156,13 +1056,11 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, NotifyBrightnessManagerScreenPowerStatus */ HWTEST_F(DisplayPowerMgrBrightnessTest, NotifyBrightnessManagerScreenPowerStatus002, TestSize.Level0) { - DISPLAY_HILOGI(LABEL_TEST, "NotifyBrightnessManagerScreenPowerStatus002 function start!"); uint32_t displayId = 0; uint32_t screenPowerStatus = 3; // 3 represent the POWER_STATUS_OFF uint32_t result = DisplayPowerMgrClient::GetInstance().NotifyBrightnessManagerScreenPowerStatus(displayId, screenPowerStatus); const uint32_t FAILED_RESULT = 0; EXPECT_EQ(result, FAILED_RESULT); - DISPLAY_HILOGI(LABEL_TEST, "NotifyBrightnessManagerScreenPowerStatus002 function end!"); } } // namespace \ No newline at end of file