1 /* 2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <gtest/gtest.h> 17 #include "display_brightness_callback_stub.h" 18 #include "display_power_mgr_client.h" 19 #include "setting_provider.h" 20 #include "system_ability_definition.h" 21 #include "display_log.h" 22 #include "power_mgr_client.h" 23 24 using namespace testing; 25 using namespace testing::ext; 26 using namespace OHOS; 27 using namespace OHOS::DisplayPowerMgr; 28 29 namespace { 30 const std::string SETTING_BRIGHTNESS_KEY {"settings.display.screen_brightness_status"}; 31 const double NO_DISCOUNT = 1.00; 32 const uint32_t MAX_DEFAULT_BRIGHTNESS_LEVEL = 255; 33 const uint32_t TEST_MODE = 1; 34 const uint32_t NORMAL_MODE = 2; 35 const uint32_t DEFAULT_WAITING_TIME = 1200000; 36 } 37 38 class DisplayPowerMgrBrightnessTest : public Test { 39 public: SetUp()40 void SetUp() 41 { 42 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON); 43 DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(false); 44 DisplayPowerMgrClient::GetInstance().DiscountBrightness(NO_DISCOUNT); 45 uint32_t maxBrightness = DisplayPowerMgrClient::GetInstance().GetMaxBrightness(); 46 DisplayPowerMgrClient::GetInstance().SetMaxBrightness((double)maxBrightness / MAX_DEFAULT_BRIGHTNESS_LEVEL, 47 TEST_MODE); 48 49 auto& powerMgrClient = PowerMgr::PowerMgrClient::GetInstance(); 50 PowerMgr::PowerMode mode = powerMgrClient.GetDeviceMode(); 51 if (mode == PowerMgr::PowerMode::POWER_SAVE_MODE || mode == PowerMgr::PowerMode::EXTREME_POWER_SAVE_MODE) { 52 powerMgrClient.SetDeviceMode(PowerMgr::PowerMode::NORMAL_MODE); 53 } 54 } 55 TearDown()56 void TearDown() 57 { 58 DisplayPowerMgrClient::GetInstance().RestoreBrightness(); 59 DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); 60 uint32_t maxBrightness = DisplayPowerMgrClient::GetInstance().GetMaxBrightness(); 61 DisplayPowerMgrClient::GetInstance().SetMaxBrightness((double)maxBrightness / MAX_DEFAULT_BRIGHTNESS_LEVEL, 62 NORMAL_MODE); 63 } 64 }; 65 66 namespace { 67 /** 68 * @tc.name: DisplayPowerMgrSetBrightness001 69 * @tc.desc: Test SetBrightness 70 * @tc.type: FUNC 71 */ 72 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetBrightness001, TestSize.Level0) 73 { 74 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetBrightness001 function start!"); 75 const uint32_t SET_BRIGHTNESS = 90; 76 bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 77 EXPECT_TRUE(ret); 78 const int sleepTime = DEFAULT_WAITING_TIME; 79 usleep(sleepTime); 80 uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 81 EXPECT_EQ(deviceBrightness, SET_BRIGHTNESS); 82 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetBrightness001 function end!"); 83 } 84 85 /** 86 * @tc.name: DisplayPowerMgrSettingBrightness001 87 * @tc.desc: Test setting brightness value changed when SetBrightness 88 * @tc.type: FUNC 89 */ 90 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSettingBrightness001, TestSize.Level0) 91 { 92 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSettingBrightness001 function start!"); 93 const uint32_t SET_BRIGHTNESS_VALUE = 223; 94 bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS_VALUE); 95 EXPECT_TRUE(ret); 96 const int sleepTime = DEFAULT_WAITING_TIME; 97 usleep(sleepTime); // sleep 100ms, wait for setting update 98 uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); 99 EXPECT_EQ(brightness, SET_BRIGHTNESS_VALUE); 100 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSettingBrightness001 function end!"); 101 } 102 103 /** 104 * @tc.name: DisplayPowerMgrDiscountBrightnessNormal 105 * @tc.desc: Test DiscountBrightness the normal test 106 * @tc.type: FUNC 107 * @tc.require: issueI5HWMN 108 */ 109 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessNormal, TestSize.Level0) 110 { 111 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessNormal function start!"); 112 const uint32_t SET_BRIGHTNESS = 91; 113 const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 114 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 115 usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness 116 const double DISCOUNT_NORMAL = 0.8; 117 bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_NORMAL); 118 EXPECT_TRUE(ret); 119 120 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 121 EXPECT_EQ(value, static_cast<uint32_t>(SET_BRIGHTNESS * DISCOUNT_NORMAL)); 122 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessNormal function end!"); 123 } 124 125 /** 126 * @tc.name: DisplayPowerMgrDiscountBrightnessNormal 127 * @tc.desc: Test DiscountBrightness when screen is off 128 * @tc.type: FUNC 129 * @tc.require: issueI5HWMN 130 */ 131 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessScreenOff, TestSize.Level0) 132 { 133 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessScreenOff function start!"); 134 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF); 135 const double DISCOUNT_VALUE = 0.7; 136 bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_VALUE); 137 EXPECT_FALSE(ret); 138 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessScreenOff function end!"); 139 } 140 141 /** 142 * @tc.name: DisplayPowerMgrDiscountBrightnessBoundary001 143 * @tc.desc: Test DiscountBrightness the boundary test 144 * @tc.type: FUNC 145 * @tc.require: issueI5HWMN 146 */ 147 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessBoundary001, TestSize.Level0) 148 { 149 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessBoundary001 function start!"); 150 const uint32_t SET_BRIGHTNESS = 92; 151 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 152 usleep(DEFAULT_WAITING_TIME); 153 const double DISCOUNT_LOWER_BOUNDARY = 0.01; 154 bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_LOWER_BOUNDARY); 155 EXPECT_TRUE(ret); 156 157 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 158 uint32_t minBrightness = DisplayPowerMgrClient::GetInstance().GetMinBrightness(); 159 EXPECT_EQ(value, minBrightness); 160 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessBoundary001 function end!"); 161 } 162 163 /** 164 * @tc.name: DisplayPowerMgrDiscountBrightnessBoundary002 165 * @tc.desc: Test DiscountBrightness the boundary test 166 * @tc.type: FUNC 167 * @tc.require: issueI5HWMN 168 */ 169 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessBoundary002, TestSize.Level0) 170 { 171 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessBoundary002 function start!"); 172 const uint32_t SET_BRIGHTNESS = 93; 173 const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 174 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 175 usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness 176 const double DISCOUNT_UPPER_BOUNDARY = 1.0; 177 bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_UPPER_BOUNDARY); 178 EXPECT_TRUE(ret); 179 180 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 181 EXPECT_EQ(value, static_cast<uint32_t>(SET_BRIGHTNESS * DISCOUNT_UPPER_BOUNDARY)); 182 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessBoundary002 function end!"); 183 } 184 185 /** 186 * @tc.name: DisplayPowerMgrDiscountBrightnessAbnormal001 187 * @tc.desc: Test DiscountBrightness the abnormal test 188 * @tc.type: FUNC 189 * @tc.require: issueI5HWMN 190 */ 191 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessAbnormal001, TestSize.Level0) 192 { 193 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessAbnormal001 function start!"); 194 const uint32_t SET_BRIGHTNESS = 94; 195 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 196 usleep(DEFAULT_WAITING_TIME); 197 const double DISCOUNT_BEYOND_LOWER_BOUNDARY = 0.0; 198 bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_BEYOND_LOWER_BOUNDARY); 199 EXPECT_TRUE(ret); 200 201 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 202 uint32_t minBrightness = DisplayPowerMgrClient::GetInstance().GetMinBrightness(); 203 EXPECT_EQ(value, minBrightness); 204 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessAbnormal001 function end!"); 205 } 206 207 /** 208 * @tc.name: DisplayPowerMgrDiscountBrightnessAbnormal002 209 * @tc.desc: Test DiscountBrightness the abnormal test 210 * @tc.type: FUNC 211 * @tc.require: issueI5HWMN 212 */ 213 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessAbnormal002, TestSize.Level0) 214 { 215 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessAbnormal002 function start!"); 216 const uint32_t SET_BRIGHTNESS = 95; 217 const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 218 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 219 usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness 220 const double DISCOUNT_BEYOND_UPPER_BOUNDARY = 2.0; 221 bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_BEYOND_UPPER_BOUNDARY); 222 EXPECT_TRUE(ret); 223 224 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 225 const double DISCOUNT_MAX_VALUE = 1.0; 226 EXPECT_EQ(value, static_cast<uint32_t>(SET_BRIGHTNESS * DISCOUNT_MAX_VALUE)); 227 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessAbnormal002 function end!"); 228 } 229 230 /** 231 * @tc.name: DisplayPowerMgrDiscountBrightnessAbnormal003 232 * @tc.desc: Test DiscountBrightness the abnormal test 233 * @tc.type: FUNC 234 * @tc.require: issueI5HWMN 235 */ 236 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightnessAbnormal003, TestSize.Level0) 237 { 238 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessAbnormal003 function start!"); 239 const uint32_t SET_BRIGHTNESS = 96; 240 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 241 usleep(DEFAULT_WAITING_TIME); 242 const double DISCOUNT_NEGATIVE_VALUE = -1.0; 243 bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_NEGATIVE_VALUE); 244 EXPECT_TRUE(ret); 245 246 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 247 uint32_t minBrightness = DisplayPowerMgrClient::GetInstance().GetMinBrightness(); 248 EXPECT_EQ(value, minBrightness); 249 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightnessAbnormal003 function end!"); 250 } 251 252 /** 253 * @tc.name: DisplayPowerMgrDiscountBrightness001 254 * @tc.desc: Test OverrideBrightness after DiscountBrightness, then RestoreBrightness 255 * @tc.type: FUNC 256 * @tc.require: issueI5HWMN 257 */ 258 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness001, TestSize.Level0) 259 { 260 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness001 function start!"); 261 const uint32_t SET_BRIGHTNESS = 97; 262 const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 263 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 264 usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness 265 const double DISCOUNT_VALUE = 0.7; 266 bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_VALUE); 267 EXPECT_TRUE(ret); 268 269 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 270 EXPECT_EQ(value, static_cast<uint32_t>(DISCOUNT_VALUE * SET_BRIGHTNESS)); 271 272 const uint32_t SET_OVERRIDE_BRIGHTNESS = 202; 273 DisplayPowerMgrClient::GetInstance().OverrideBrightness(SET_OVERRIDE_BRIGHTNESS); 274 usleep(DEFAULT_WAITING_TIME); 275 value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 276 EXPECT_EQ(value, static_cast<uint32_t>(DISCOUNT_VALUE * SET_OVERRIDE_BRIGHTNESS)); 277 278 DisplayPowerMgrClient::GetInstance().RestoreBrightness(); 279 usleep(DEFAULT_WAITING_TIME); 280 value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 281 EXPECT_EQ(value, static_cast<uint32_t>(DISCOUNT_VALUE * SET_BRIGHTNESS)); 282 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness001 function end!"); 283 } 284 285 /** 286 * @tc.name: DisplayPowerMgrDiscountBrightness002 287 * @tc.desc: Test DiscountBrightness after OverrideBrightness, then RestoreBrightness 288 * @tc.type: FUNC 289 * @tc.require: issueI5HWMN 290 */ 291 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness002, TestSize.Level0) 292 { 293 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness002 function start!"); 294 const uint32_t SET_BRIGHTNESS = 150; 295 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 296 const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 297 usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness 298 const uint32_t SET_OVERRIDE_BRIGHTNESS = 202; 299 DisplayPowerMgrClient::GetInstance().OverrideBrightness(SET_OVERRIDE_BRIGHTNESS); 300 301 const double DISCOUNT_VALUE = 0.7; 302 double ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_VALUE); 303 EXPECT_TRUE(ret); 304 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 305 EXPECT_TRUE(value <= static_cast<uint32_t>(DISCOUNT_VALUE * SET_OVERRIDE_BRIGHTNESS)); 306 307 ret = DisplayPowerMgrClient::GetInstance().RestoreBrightness(); 308 usleep(DEFAULT_WAITING_TIME); 309 EXPECT_TRUE(ret); 310 311 value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 312 EXPECT_EQ(value, static_cast<uint32_t>(DISCOUNT_VALUE * SET_BRIGHTNESS)); 313 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness002 function end!"); 314 } 315 316 /** 317 * @tc.name: DisplayPowerMgrDiscountBrightness003 318 * @tc.desc: Test DisconutBrightness after BoostBrightness and CancelBoostBrightness 319 * @tc.type: FUNC 320 * @tc.require: issueI5HWMN 321 */ 322 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness003, TestSize.Level0) 323 { 324 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness003 function start!"); 325 const uint32_t SET_BRIGHTNESS = 99; 326 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 327 const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 328 usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness 329 const uint32_t SET_BOOST_BRIGHTNESS_TIME = 10000; 330 DisplayPowerMgrClient::GetInstance().BoostBrightness(SET_BOOST_BRIGHTNESS_TIME); 331 332 const double DISCOUNT_VALUE = 0.7; 333 bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_VALUE); 334 EXPECT_TRUE(ret); 335 336 uint32_t maxBrightness = DisplayPowerMgrClient::GetInstance().GetMaxBrightness(); 337 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 338 EXPECT_EQ(value, static_cast<uint32_t>(DISCOUNT_VALUE * maxBrightness)); 339 340 DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); 341 342 value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 343 EXPECT_EQ(value, static_cast<uint32_t>(DISCOUNT_VALUE * SET_BRIGHTNESS)); 344 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness003 function end!"); 345 } 346 347 /** 348 * @tc.name: DisplayPowerMgrDiscountBrightness004 349 * @tc.desc: Test BoostBrightness after DiscountBrightness, then CancelBoostBrightness 350 * @tc.type: FUNC 351 * @tc.require: issueI5HWMN 352 */ 353 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness004, TestSize.Level0) 354 { 355 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness004 function start!"); 356 const uint32_t SET_BRIGHTNESS = 100; 357 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 358 const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 359 usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness 360 const double DISCOUNT_VALUE = 0.7; 361 bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_VALUE); 362 EXPECT_TRUE(ret); 363 364 const uint32_t SET_BOOST_BRIGHTNESS_TIME = 10000; 365 DisplayPowerMgrClient::GetInstance().BoostBrightness(SET_BOOST_BRIGHTNESS_TIME); 366 uint32_t maxBrightness = DisplayPowerMgrClient::GetInstance().GetMaxBrightness(); 367 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 368 EXPECT_EQ(value, static_cast<uint32_t>(DISCOUNT_VALUE * maxBrightness)); 369 370 DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); 371 372 value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 373 EXPECT_EQ(value, static_cast<uint32_t>(DISCOUNT_VALUE * SET_BRIGHTNESS)); 374 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness004 function end!"); 375 } 376 377 /** 378 * @tc.name: DisplayPowerMgrDiscountBrightness005 379 * @tc.desc: Test DisconutBrightness after SetBrightness, then GetBrightness 380 * @tc.type: FUNC 381 * @tc.require: issueI5HWMN 382 */ 383 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness005, TestSize.Level0) 384 { 385 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness005 function start!"); 386 const uint32_t SET_BRIGHTNESS = 103; 387 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 388 usleep(DEFAULT_WAITING_TIME); 389 const double DISCOUNT_VALUE = 0.7; 390 bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_VALUE); 391 EXPECT_TRUE(ret); 392 const int sleepTime = 100000; 393 usleep(sleepTime); // sleep 100ms, wait for setting update 394 uint32_t beforeBrightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); 395 EXPECT_EQ(SET_BRIGHTNESS, beforeBrightness); 396 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDiscountBrightness005 function end!"); 397 } 398 399 /** 400 * @tc.name: DisplayPowerMgrOverrideBrightness001 401 * @tc.desc: Test OverrideBrightness 402 * @tc.type: FUNC 403 */ 404 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness001, TestSize.Level0) 405 { 406 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness001 function start!"); 407 const uint32_t OVERRIDE_BRIGHTNESS = 255; 408 bool ret = DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BRIGHTNESS); 409 usleep(DEFAULT_WAITING_TIME); 410 EXPECT_TRUE(ret); 411 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 412 EXPECT_EQ(value, OVERRIDE_BRIGHTNESS); 413 DisplayPowerMgrClient::GetInstance().RestoreBrightness(); 414 usleep(DEFAULT_WAITING_TIME); 415 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness001 function end!"); 416 } 417 418 /** 419 * @tc.name: DisplayPowerMgrOverrideBrightness002 420 * @tc.desc: Test RestoreBrightness after OverrideBrightness 421 * @tc.type: FUNC 422 */ 423 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness002, TestSize.Level0) 424 { 425 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness002 function start!"); 426 const uint32_t SET_BRIGHTNESS = 104; 427 const uint32_t OVERRIDE_BRIGHTNESS = 255; 428 const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 429 bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 430 usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness 431 EXPECT_TRUE(ret); 432 ret = DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BRIGHTNESS); 433 usleep(DEFAULT_WAITING_TIME); 434 EXPECT_TRUE(ret); 435 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 436 EXPECT_EQ(value, OVERRIDE_BRIGHTNESS); 437 ret = DisplayPowerMgrClient::GetInstance().RestoreBrightness(); // restore 438 usleep(DEFAULT_WAITING_TIME); 439 EXPECT_TRUE(ret); 440 value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 441 EXPECT_EQ(value, SET_BRIGHTNESS); 442 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness002 function end!"); 443 } 444 445 /** 446 * @tc.name: DisplayPowerMgrOverrideBrightness003 447 * @tc.desc: Test SetBrightness after OverrideBrightness 448 * @tc.type: FUNC 449 */ 450 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness003, TestSize.Level0) 451 { 452 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness003 function start!"); 453 const uint32_t SET_BRIGHTNESS = 105; 454 const uint32_t OVERRIDE_BRIGHTNESS = 255; 455 bool ret = DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BRIGHTNESS); 456 usleep(DEFAULT_WAITING_TIME); 457 EXPECT_TRUE(ret); 458 ret = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 459 usleep(DEFAULT_WAITING_TIME); 460 EXPECT_FALSE(ret); 461 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 462 EXPECT_EQ(value, OVERRIDE_BRIGHTNESS); 463 DisplayPowerMgrClient::GetInstance().RestoreBrightness(); 464 usleep(DEFAULT_WAITING_TIME); 465 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness003 function end!"); 466 } 467 468 /** 469 * @tc.name: DisplayPowerMgrOverrideBrightness004 470 * @tc.desc: Test RestoreBrightness after not override 471 * @tc.type: FUNC 472 */ 473 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness004, TestSize.Level0) 474 { 475 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness004 function start!"); 476 const uint32_t SET_BRIGHTNESS = 106; 477 bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 478 usleep(DEFAULT_WAITING_TIME); 479 EXPECT_TRUE(ret); 480 ret = DisplayPowerMgrClient::GetInstance().RestoreBrightness(); 481 EXPECT_FALSE(ret); 482 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 483 EXPECT_EQ(value, SET_BRIGHTNESS); 484 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness004 function end!"); 485 } 486 487 /** 488 * @tc.name: DisplayPowerMgrOverrideBrightness005 489 * @tc.desc: Test OverrideBrightness off Disable the call 490 * @tc.type: FUNC 491 */ 492 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness005, TestSize.Level0) 493 { 494 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness005 function start!"); 495 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF); 496 const uint32_t OVERRIDE_BRIGHTNESS = 100; 497 bool isBoost = DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BRIGHTNESS); 498 EXPECT_FALSE(isBoost); 499 bool isRestore = DisplayPowerMgrClient::GetInstance().RestoreBrightness(); 500 EXPECT_FALSE(isRestore); 501 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness005 function end!"); 502 } 503 504 /** 505 * @tc.name: DisplayPowerMgrOverrideBrightness006 506 * @tc.desc: Test device brightness when override brightness is 256 507 * @tc.type: FUNC 508 * @tc.require: issueI5YZQR 509 */ 510 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness006, TestSize.Level0) 511 { 512 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness006 function start!"); 513 uint32_t overrideValue = 256; 514 uint32_t brightnessMax = 255; 515 DisplayPowerMgrClient::GetInstance().OverrideBrightness(overrideValue); 516 usleep(DEFAULT_WAITING_TIME); 517 uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 518 EXPECT_EQ(brightnessMax, deviceBrightness); 519 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness006 function end!"); 520 } 521 522 /** 523 * @tc.name: DisplayPowerMgrOverrideBrightness007 524 * @tc.desc: Test device brightness when override brightness is 0 525 * @tc.type: FUNC 526 * @tc.require: issueI5YZQR 527 */ 528 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness007, TestSize.Level0) 529 { 530 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness007 function start!"); 531 uint32_t overrideValue = 0; 532 uint32_t brightnessMin = DisplayPowerMgrClient::GetInstance().GetMinBrightness(); 533 EXPECT_TRUE(DisplayPowerMgrClient::GetInstance().OverrideBrightness(overrideValue)); 534 usleep(DEFAULT_WAITING_TIME); 535 uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 536 EXPECT_EQ(brightnessMin, deviceBrightness); 537 DisplayPowerMgrClient::GetInstance().RestoreBrightness(); 538 usleep(DEFAULT_WAITING_TIME); 539 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness007 function end!"); 540 } 541 542 /** 543 * @tc.name: DisplayPowerMgrOverrideBrightness008 544 * @tc.desc: Test device brightness when override brightness is -1 545 * @tc.type: FUNC 546 * @tc.require: issueI5YZQR 547 */ 548 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness008, TestSize.Level0) 549 { 550 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness008 function start!"); 551 uint32_t overrideValue = -1; 552 uint32_t brightnessMax = 255; 553 EXPECT_TRUE(DisplayPowerMgrClient::GetInstance().OverrideBrightness(overrideValue)); 554 usleep(DEFAULT_WAITING_TIME); 555 uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 556 EXPECT_EQ(brightnessMax, deviceBrightness); 557 DisplayPowerMgrClient::GetInstance().RestoreBrightness(); 558 usleep(DEFAULT_WAITING_TIME); 559 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness008 function end!"); 560 } 561 562 /** 563 * @tc.name: DisplayPowerMgrOverrideBrightness009 564 * @tc.desc: Set brightness after override brightness, then exit override brightness, the 565 * restore brightness should be brightness value of thr current device 566 * @tc.type: FUNC 567 * @tc.require: issueI6ACLX 568 */ 569 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness009, TestSize.Level0) 570 { 571 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness009 function start!"); 572 const uint32_t OVERRIDE_BRIGHTNESS = 156; 573 const uint32_t SET_BRIGHTNESS = 66; 574 auto currentBrightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); 575 bool ret1 = DisplayPowerMgrClient::GetInstance().SetBrightness(currentBrightness); 576 usleep(DEFAULT_WAITING_TIME); 577 EXPECT_TRUE(ret1); 578 DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BRIGHTNESS); 579 usleep(DEFAULT_WAITING_TIME); 580 bool ret2 = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 581 usleep(DEFAULT_WAITING_TIME); 582 EXPECT_FALSE(ret2); 583 DisplayPowerMgrClient::GetInstance().RestoreBrightness(); 584 usleep(DEFAULT_WAITING_TIME); 585 uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 586 EXPECT_EQ(currentBrightness, deviceBrightness); 587 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness009 function end!"); 588 } 589 590 /** 591 * @tc.name: DisplayPowerMgrMaxBrightness001 592 * @tc.desc: Test GetMaxBrightness less equals 255 593 * @tc.type: FUNC 594 */ 595 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrMaxBrightness001, TestSize.Level0) 596 { 597 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrMaxBrightness001 function start!"); 598 uint32_t max = DisplayPowerMgrClient::GetInstance().GetMaxBrightness(); 599 EXPECT_LE(max, 255); 600 bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(max + 100); 601 usleep(DEFAULT_WAITING_TIME); // sleep 100ms, wait for setting update 602 EXPECT_TRUE(ret); 603 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 604 EXPECT_EQ(value, max); 605 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrMaxBrightness001 function end!"); 606 } 607 608 /** 609 * @tc.name: DisplayPowerMgrMinBrightness001 610 * @tc.desc: Test GetMinBrightness greater equals 0 611 * @tc.type: FUNC 612 */ 613 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrMinBrightness001, TestSize.Level0) 614 { 615 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrMinBrightness001 function start!"); 616 const uint32_t SET_BRIGHTNESS_VALUE = 0; 617 uint32_t min = DisplayPowerMgrClient::GetInstance().GetMinBrightness(); 618 EXPECT_GE(min, 0); 619 bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS_VALUE); 620 usleep(DEFAULT_WAITING_TIME); // sleep 100ms, wait for setting update 621 EXPECT_TRUE(ret); 622 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 623 EXPECT_EQ(value, min); 624 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrMinBrightness001 function end!"); 625 } 626 627 /** 628 * @tc.name: DisplayPowerMgrDefaultBrightness001 629 * @tc.desc: Test GetDefaultnBrightness greater equals 0 and less equals 255 630 * @tc.type: FUNC 631 */ 632 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDefaultBrightness001, TestSize.Level0) 633 { 634 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDefaultBrightness001 function start!"); 635 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDefaultBrightness(); 636 EXPECT_GE(value, 0); 637 EXPECT_LE(value, 255); 638 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDefaultBrightness001 function end!"); 639 } 640 641 /** 642 * @tc.name: DisplayPowerMgrBoostBrightnessNormal 643 * @tc.desc: Test BoostBrightness the normal test 644 * @tc.type: FUNC 645 */ 646 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessNormal, TestSize.Level0) 647 { 648 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessNormal function start!"); 649 const uint32_t BOOST_TIME = 100; // keep BoostBrightness 100ms 650 bool isSucc = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_TIME); 651 EXPECT_TRUE(isSucc); 652 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessNormal function end!"); 653 } 654 655 /** 656 * @tc.name: DisplayPowerMgrBoostBrightnessAbnormal 657 * @tc.desc: Test BoostBrightness the abnormal value 658 * @tc.type: FUNC 659 */ 660 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessAbnormal, TestSize.Level0) 661 { 662 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessAbnormal function start!"); 663 const uint32_t BOOST_TIME = -1; 664 bool isSucc = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_TIME); 665 EXPECT_FALSE(isSucc); 666 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessAbnormal function end!"); 667 } 668 669 /** 670 * @tc.name: DisplayPowerMgrCancelBoostBrightnessNormal 671 * @tc.desc: Test CancelBoostBrightness the normal test 672 * @tc.type: FUNC 673 */ 674 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrCancelBoostBrightnessNormal, TestSize.Level0) 675 { 676 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrCancelBoostBrightnessNormal function start!"); 677 const uint32_t BOOST_TIME = 50000; 678 bool isSucc = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_TIME); 679 EXPECT_TRUE(isSucc); 680 bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); 681 EXPECT_TRUE(isCancel); 682 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrCancelBoostBrightnessNormal function end!"); 683 } 684 685 /** 686 * @tc.name: BoostAndOverrideMutuallyExclusive1 687 * @tc.desc: Test BoostBrightness and OverrideBrightness are mutually exclusive 688 * @tc.type: FUNC 689 */ 690 HWTEST_F(DisplayPowerMgrBrightnessTest, BoostAndOverrideMutuallyExclusive1, TestSize.Level0) 691 { 692 DISPLAY_HILOGI(LABEL_TEST, "BoostAndOverrideMutuallyExclusive function start!"); 693 const uint32_t BOOST_TIME = 50000; 694 const uint32_t OVERRIDE_BIRGHTNESS = 100; 695 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_TIME); 696 EXPECT_TRUE(isBoost); 697 bool isOverride = DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BIRGHTNESS); 698 EXPECT_FALSE(isOverride); 699 bool isRestore = DisplayPowerMgrClient::GetInstance().RestoreBrightness(); 700 EXPECT_FALSE(isRestore); 701 DISPLAY_HILOGI(LABEL_TEST, "BoostAndOverrideMutuallyExclusive function end!"); 702 } 703 704 /** 705 * @tc.name: BoostAndOverrideMutuallyExclusive2 706 * @tc.desc: Test BoostBrightness and OverrideBrightness are mutually exclusive 707 * @tc.type: FUNC 708 */ 709 HWTEST_F(DisplayPowerMgrBrightnessTest, BoostAndOverrideMutuallyExclusive2, TestSize.Level0) 710 { 711 DISPLAY_HILOGI(LABEL_TEST, "BoostAndOverrideMutuallyExclusive2 function start!"); 712 const uint32_t BOOST_TIME = 50000; 713 const uint32_t OVERRIDE_BIRGHTNESS = 255; 714 bool isOverride = DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BIRGHTNESS); 715 EXPECT_TRUE(isOverride); 716 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_TIME); 717 EXPECT_FALSE(isBoost); 718 bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); 719 EXPECT_FALSE(isCancel); 720 DisplayPowerMgrClient::GetInstance().RestoreBrightness(); 721 usleep(DEFAULT_WAITING_TIME); 722 DISPLAY_HILOGI(LABEL_TEST, "BoostAndOverrideMutuallyExclusive2 function end!"); 723 } 724 725 /** 726 * @tc.name: DisplayPowerMgrBoostBrightnessTimeout1 727 * @tc.desc: Test BoostBrightness timeout restore system brightness 728 * @tc.type: FUNC 729 */ 730 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessTimeout1, TestSize.Level0) 731 { 732 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessTimeout1 function start!"); 733 uint32_t beforeValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 734 const uint32_t BOOST_BRIGHTNESS_TIME = 100; 735 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); 736 EXPECT_TRUE(isBoost); 737 const int sleepTime = 200000; 738 usleep(sleepTime); // sleep 200ms, wait for setting update 739 uint32_t currentValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 740 EXPECT_EQ(beforeValue, currentValue); 741 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessTimeout1 function end!"); 742 } 743 744 /** 745 * @tc.name: DisplayPowerMgrBoostBrightnessTimeout2 746 * @tc.desc: Test BoostBrightness timeout brightness adjustment can be called 747 * @tc.type: FUNC 748 */ 749 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessTimeout2, TestSize.Level0) 750 { 751 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessTimeout2 function start!"); 752 const uint32_t SET_BRIGHTNESS = 106; 753 const uint32_t BOOST_BRIGHTNESS_TIME = 100; 754 const int sleepTime = (BOOST_BRIGHTNESS_TIME + 50) * 1000; // wait for (100 + 50)ms BoostBrightness timeout 755 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); 756 EXPECT_TRUE(isBoost); 757 usleep(sleepTime); // sleep 100ms, wait for cancel BoostBrightness 758 bool isSet = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 759 usleep(DEFAULT_WAITING_TIME); // sleep 100ms, wait for setting update 760 EXPECT_TRUE(isSet); 761 uint32_t currentValue = DisplayPowerMgrClient::GetInstance().GetBrightness(); 762 EXPECT_EQ(SET_BRIGHTNESS, currentValue); 763 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessTimeout2 function end!"); 764 } 765 766 /** 767 * @tc.name: DisplayPowerMgrBoostBrightnessCancel1 768 * @tc.desc: Test BoostBrightness Cancel restore system brightness 769 * @tc.type: FUNC 770 */ 771 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessCancel1, TestSize.Level0) 772 { 773 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessCancel1 function start!"); 774 const uint32_t SET_BRIGHTNESS = 106; 775 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 776 const int32_t SET_SLEEP_TIME = DEFAULT_WAITING_TIME; 777 usleep(SET_SLEEP_TIME); // sleep 200ms, wait for setBrightness 778 const uint32_t BOOST_BRIGHTNESS_TIME = 10000; 779 const int SLEEP_TIME = 100000; 780 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); 781 EXPECT_TRUE(isBoost); 782 bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); 783 EXPECT_TRUE(isCancel); 784 usleep(SLEEP_TIME); // sleep 100ms, wait for cancel BoostBrightness 785 uint32_t currentValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 786 EXPECT_EQ(SET_BRIGHTNESS, currentValue) << "beforeValue: " << SET_BRIGHTNESS << " currentVal: " << currentValue; 787 DISPLAY_HILOGI(LABEL_TEST, "BoostBrightnessCancel1: beforeValue: %{public}d, currentVal: %{public}d", 788 SET_BRIGHTNESS, currentValue); 789 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessCancel1 function end!"); 790 } 791 792 /** 793 * @tc.name: DisplayPowerMgrBoostBrightnessCancel2 794 * @tc.desc: Test BoostBrightness Cancel brightness adjustment can be called 795 * @tc.type: FUNC 796 */ 797 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessCancel2, TestSize.Level0) 798 { 799 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessCancel2 function start!"); 800 const uint32_t BOOST_BRIGHTNESS_TIME = 10000; 801 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); 802 EXPECT_TRUE(isBoost); 803 bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); 804 EXPECT_TRUE(isCancel); 805 const uint32_t SET_BRIGHTNESS_VALUE = 111; 806 bool isSet = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS_VALUE); 807 usleep(DEFAULT_WAITING_TIME); // sleep 100ms, wait for setting update 808 EXPECT_TRUE(isSet); 809 uint32_t currentValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 810 EXPECT_EQ(SET_BRIGHTNESS_VALUE, currentValue); 811 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessCancel2 function end!"); 812 } 813 814 /** 815 * @tc.name: DisplayPowerMgrBoostBrightnessNotAdjust 816 * @tc.desc: Test BoostBrightness do not adjust brightness, but update cachedSettingBrightness 817 * @tc.type: FUNC 818 */ 819 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessNotAdjust, TestSize.Level0) 820 { 821 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessNotAdjust function start!"); 822 const uint32_t SET_BRIGHTNESS = 107; 823 const uint32_t BOOST_BRIGHTNESS_TIME = 10000; 824 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 825 usleep(DEFAULT_WAITING_TIME); 826 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); 827 EXPECT_TRUE(isBoost); 828 bool isSet = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 829 usleep(DEFAULT_WAITING_TIME); 830 EXPECT_FALSE(isSet); 831 DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); 832 uint32_t currentValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 833 EXPECT_EQ(SET_BRIGHTNESS, currentValue); 834 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessNotAdjust function end!"); 835 } 836 837 /** 838 * @tc.name: DisplayPowerMgrBoostBrightnessScreenOff 839 * @tc.desc: Test BoostBrightness off Disable the call 840 * @tc.type: FUNC 841 */ 842 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessScreenOff, TestSize.Level0) 843 { 844 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessScreenOff function start!"); 845 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF); 846 const uint32_t BOOST_BRIGHTNESS_TIME = 10000; 847 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); 848 EXPECT_FALSE(isBoost); 849 bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); 850 EXPECT_FALSE(isCancel); 851 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessScreenOff function end!"); 852 } 853 854 /** 855 * @tc.name: DisplayPowerMgrBoostBrightnessMultipleCalls 856 * @tc.desc: Test BoostBrightness multiple calls 857 * @tc.type: FUNC 858 */ 859 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessMultipleCalls, TestSize.Level0) 860 { 861 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessMultipleCalls function start!"); 862 const uint32_t SET_BRIGHTNESS = 108; 863 const uint32_t COUNT = 3; 864 const uint32_t TIMEOUT = 100; 865 const uint32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 866 const uint32_t UPDATE_TIME = 20000; 867 for (uint32_t i = 0; i < COUNT; ++i) { 868 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(TIMEOUT); 869 usleep(UPDATE_TIME); // wait for set newest BoostBrightness time 870 EXPECT_TRUE(isBoost); 871 } 872 // Brightness adjustment is not allowed 873 bool isSet = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 874 EXPECT_FALSE(isSet); 875 // Wait for a timeout 876 usleep(SLEEP_TIME); 877 bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); 878 EXPECT_FALSE(isCancel); 879 const uint32_t SET_BRIGHTNESS_VALUE = 222; 880 isSet = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS_VALUE); 881 usleep(DEFAULT_WAITING_TIME); 882 EXPECT_TRUE(isSet); 883 uint32_t currentVal = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 884 EXPECT_EQ(SET_BRIGHTNESS_VALUE, currentVal); 885 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessMultipleCalls function end!"); 886 } 887 888 /** 889 * @tc.name: DisplayPowerMgrAdjustBrightness001 890 * @tc.desc: Test AdjustBrightness 891 * @tc.type: FUNC 892 */ 893 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrAdjustBrightness001, TestSize.Level0) 894 { 895 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness001 function start!"); 896 bool ret = DisplayPowerMgrClient::GetInstance().AdjustBrightness(0, 3000); 897 EXPECT_TRUE(ret); 898 DisplayPowerMgrClient::GetInstance().AdjustBrightness(0, 5); 899 usleep(10000); 900 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness001 function end!"); 901 } 902 903 /** 904 * @tc.name: DisplayPowerMgrAdjustBrightness002 905 * @tc.desc: Test AutoAdjustBrightness 906 * @tc.type: FUNC 907 */ 908 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrAdjustBrightness002, TestSize.Level0) 909 { 910 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness002 function start!"); 911 bool ret = DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(true); 912 //waiting to find correct isSettingEnable value 913 usleep(50000); 914 if (ret) { 915 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness002: is supported"); 916 ret = DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(false); 917 //waiting to find correct isSettingEnable value 918 usleep(50000); 919 EXPECT_TRUE(ret); 920 } else { 921 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness002: is not supported"); 922 EXPECT_FALSE(ret); 923 } 924 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness002 function end!"); 925 } 926 927 /** 928 * @tc.name: DisplayPowerMgrAdjustBrightness003 929 * @tc.desc: Test IsAutoAdjustBrightness 930 * @tc.type: FUNC 931 * @tc.require: issueI5YZQR 932 */ 933 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrAdjustBrightness003, TestSize.Level0) 934 { 935 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness003 function start!"); 936 bool ret = DisplayPowerMgrClient::GetInstance().IsAutoAdjustBrightness(); 937 DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(false); 938 //waiting to find correct isSettingEnable value 939 usleep(50000); 940 EXPECT_EQ(DisplayPowerMgrClient::GetInstance().IsAutoAdjustBrightness(), false); 941 DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(ret); 942 //waiting to find correct isSettingEnable value 943 usleep(50000); 944 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness003 function end!"); 945 } 946 947 /** 948 * @tc.name: DisplayPowerMgrScreenBrightnessEquality001 949 * @tc.desc: Test whether the screen brightness is equal after the screen is on and before the screen is off 950 * @tc.type: FUNC 951 * @tc.require: issueI5YZQR 952 */ 953 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrScreenBrightnessEquality001, TestSize.Level0) 954 { 955 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrScreenBrightnessEquality001 function start!"); 956 DisplayPowerMgrClient::GetInstance().AdjustBrightness(0, 5); 957 usleep(10000); 958 uint32_t deviceBrightness1 = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 959 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF); 960 DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(true); 961 //waiting to find correct isSettingEnable value 962 usleep(50000); 963 DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(false); 964 //waiting to find correct isSettingEnable value 965 usleep(50000); 966 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON); 967 uint32_t deviceBrightness2 = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 968 EXPECT_EQ(deviceBrightness1, deviceBrightness2); 969 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrScreenBrightnessEquality001 function end!"); 970 } 971 972 /** 973 * @tc.name: DisplayPowerMgrSleepBrightness001 974 * @tc.desc: Test after entering the dim mode, settings brightness to remain unchanged 975 * @tc.type: FUNC 976 * @tc.require: issueI5YZQR 977 */ 978 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSleepBrightness001, TestSize.Level0) 979 { 980 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSleepBrightness001 function start!"); 981 uint32_t deviceBrightness1 = DisplayPowerMgrClient::GetInstance().GetBrightness(); 982 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_DIM); 983 //waiting to find correct isSettingEnable value 984 usleep(50000); 985 uint32_t deviceBrightness2 = DisplayPowerMgrClient::GetInstance().GetBrightness(); 986 EXPECT_EQ(deviceBrightness1, deviceBrightness2); 987 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON); 988 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSleepBrightness001 function end!"); 989 } 990 991 /** 992 * @tc.name: DisplayPowerMgrSetLightBrightnessThreshold001 993 * @tc.desc: Test the Function of setting Ambient Light Monitor (success is returned) 994 * @tc.type: FUNC 995 * @tc.require: issueI8ZHFN 996 */ 997 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetLightBrightnessThreshold001, TestSize.Level0) 998 { 999 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetLightBrightnessThreshold001 function start!"); 1000 std::vector<int32_t> threshold = {200, 200, 20}; 1001 uint32_t type = 1; 1002 int32_t state = 0; 1003 const uint32_t SUCCESS_RESULT = 1; 1004 sptr<DisplayBrightnessCallbackStub> callback = new DisplayBrightnessCallbackStub(); 1005 callback->OnNotifyApsLightBrightnessChange(type, state); 1006 uint32_t result = DisplayPowerMgrClient::GetInstance().SetLightBrightnessThreshold(threshold, callback); 1007 EXPECT_EQ(result, SUCCESS_RESULT); 1008 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetLightBrightnessThreshold001 function end!"); 1009 } 1010 1011 /** 1012 * @tc.name: DisplayPowerMgrSetLightBrightnessThreshold002 1013 * @tc.desc: Test the Function of setting Ambient Light Monitor (success is returned) 1014 * @tc.type: FUNC 1015 * @tc.require: issueI8ZHFN 1016 */ 1017 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetLightBrightnessThreshold002, TestSize.Level0) 1018 { 1019 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetLightBrightnessThreshold002 function start!"); 1020 std::vector<int32_t> threshold = {}; 1021 uint32_t type = 1; 1022 int32_t state = 0; 1023 const uint32_t FAILD_RESULT = 0; 1024 sptr<DisplayBrightnessCallbackStub> callback = new DisplayBrightnessCallbackStub(); 1025 callback->OnNotifyApsLightBrightnessChange(type, state); 1026 uint32_t result = DisplayPowerMgrClient::GetInstance().SetLightBrightnessThreshold(threshold, callback); 1027 EXPECT_EQ(result, FAILD_RESULT); 1028 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetLightBrightnessThreshold002 function end!"); 1029 } 1030 1031 /** 1032 * @tc.name: DisplayPowerMgrSetMaxBrightnessNit001 1033 * @tc.desc: Test if SetMaxBrightness is less than the current screen brightness, 1034 * then turn down the screen brightness to the set value. 1035 * @tc.type: FUNC 1036 */ 1037 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightnessNit001, TestSize.Level0) 1038 { 1039 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightnessNit001 function start!"); 1040 const uint32_t SET_BRIGHTNESS = 150; // mapping nit = 350 1041 const uint32_t SET_BRIGHTNESS_NIT = 350; 1042 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 1043 const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 1044 usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness 1045 1046 const uint32_t SET_MAX_BRIGHTNESS = 98; // mapping nit = 231 1047 const uint32_t SET_MAX_BRIGHTNESS_NIT = 231; 1048 bool ret = DisplayPowerMgrClient::GetInstance().SetMaxBrightnessNit(SET_MAX_BRIGHTNESS_NIT, 2); 1049 EXPECT_TRUE(ret); 1050 const int32_t SLEEP_TIME_BRIGHTNESS = 10000000; 1051 usleep(SLEEP_TIME_BRIGHTNESS); // sleep 10s, wait for setBrightness 1052 uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); 1053 EXPECT_EQ(SET_MAX_BRIGHTNESS, brightness); 1054 DisplayPowerMgrClient::GetInstance().SetMaxBrightnessNit(SET_BRIGHTNESS_NIT, 1); 1055 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightnessNit001 function end!"); 1056 } 1057 1058 /** 1059 * @tc.name: DisplayPowerMgrSetMaxBrightnessNit002 1060 * @tc.desc: Test if SetMaxBrightness is higher than the current screen brightness, just set the max range 1061 * @tc.type: FUNC 1062 */ 1063 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightnessNit002, TestSize.Level0) 1064 { 1065 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightnessNit002 function start!"); 1066 const uint32_t SET_BRIGHTNESS = 150; // mapping nit = 350 1067 const uint32_t SET_BRIGHTNESS_NIT = 350; 1068 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 1069 const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 1070 usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness 1071 1072 const uint32_t SET_MAX_BRIGHTNESS_NIT = 469; // mapping level = 200; 1073 bool ret = DisplayPowerMgrClient::GetInstance().SetMaxBrightnessNit(SET_MAX_BRIGHTNESS_NIT, 2); 1074 EXPECT_TRUE(ret); 1075 const int32_t SLEEP_TIME_BRIGHTNESS = 10000000; 1076 usleep(SLEEP_TIME_BRIGHTNESS); // sleep 10s, wait for setBrightness 1077 uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); 1078 EXPECT_EQ(SET_BRIGHTNESS, brightness); 1079 DisplayPowerMgrClient::GetInstance().SetMaxBrightnessNit(SET_BRIGHTNESS_NIT, 1); 1080 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightnessNit002 function end!"); 1081 } 1082 1083 /** 1084 * @tc.name: DisplayPowerMgrSetMaxBrightness001 1085 * @tc.desc: Test if SetMaxBrightness is less than the current screen brightness, 1086 * then turn down the screen brightness to the set value. 1087 * @tc.type: FUNC 1088 */ 1089 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightness001, TestSize.Level0) 1090 { 1091 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightness001 function start!"); 1092 const uint32_t SET_BRIGHTNESS = 150; 1093 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 1094 const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 1095 usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness 1096 1097 const uint32_t SET_MAX_BRIGHTNESS = 98; 1098 bool ret = DisplayPowerMgrClient::GetInstance().SetMaxBrightness((double)SET_MAX_BRIGHTNESS / 255, 2); 1099 EXPECT_TRUE(ret); 1100 const int32_t SLEEP_TIME_BRIGHTNESS = 10000000; 1101 usleep(SLEEP_TIME_BRIGHTNESS); // sleep 10s, wait for setBrightness 1102 uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); 1103 EXPECT_EQ(SET_MAX_BRIGHTNESS, brightness); 1104 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS, 1); 1105 usleep(SLEEP_TIME); 1106 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightness001 function end!"); 1107 } 1108 1109 /** 1110 * @tc.name: DisplayPowerMgrSetMaxBrightness002 1111 * @tc.desc: Test if SetMaxBrightness is higher than the current screen brightness, just set the max range 1112 * @tc.type: FUNC 1113 */ 1114 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightness002, TestSize.Level0) 1115 { 1116 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightness002 function start!"); 1117 const uint32_t SET_BRIGHTNESS = 150; 1118 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 1119 const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 1120 usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness 1121 1122 const uint32_t SET_MAX_BRIGHTNESS = 200; 1123 bool ret = DisplayPowerMgrClient::GetInstance().SetMaxBrightness((double)SET_MAX_BRIGHTNESS / 255, 2); 1124 EXPECT_TRUE(ret); 1125 const int32_t SLEEP_TIME_BRIGHTNESS = 10000000; 1126 usleep(SLEEP_TIME_BRIGHTNESS); // sleep 10s, wait for setBrightness 1127 uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); 1128 EXPECT_EQ(SET_BRIGHTNESS, brightness); 1129 DisplayPowerMgrClient::GetInstance().SetMaxBrightness(SET_BRIGHTNESS, 1); 1130 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightness002 function end!"); 1131 } 1132 1133 /** 1134 *@tc.name: NotifyBrightnessManagerScreenPowerStatus001 1135 *@tc.desc: Test if NotifyBrightnessManagerScreenPowerStatus is work when dms notify 1136 * brightness manager POWER_STATUS_ON 1137 *@tc.type: FUNC 1138 */ 1139 HWTEST_F(DisplayPowerMgrBrightnessTest, NotifyBrightnessManagerScreenPowerStatus001, TestSize.Level0) 1140 { 1141 DISPLAY_HILOGI(LABEL_TEST, "NotifyBrightnessManagerScreenPowerStatus001 function start!"); 1142 uint32_t displayId = 0; 1143 uint32_t screenPowerStatus = 0; // 0 represent the POWER_STATUS_ON 1144 uint32_t result = DisplayPowerMgrClient::GetInstance().NotifyBrightnessManagerScreenPowerStatus(displayId, 1145 screenPowerStatus); 1146 const uint32_t FAILED_RESULT = 0; 1147 EXPECT_EQ(result, FAILED_RESULT); 1148 DISPLAY_HILOGI(LABEL_TEST, "NotifyBrightnessManagerScreenPowerStatus001 function end!"); 1149 } 1150 1151 /** 1152 *@tc.name: NotifyBrightnessManagerScreenPowerStatus002 1153 *@tc.desc: Test if NotifyBrightnessManagerScreenPowerStatus is work when dms notify 1154 * brightness manager POWER_STATUS_OFF 1155 *@tc.type: FUNC 1156 */ 1157 HWTEST_F(DisplayPowerMgrBrightnessTest, NotifyBrightnessManagerScreenPowerStatus002, TestSize.Level0) 1158 { 1159 DISPLAY_HILOGI(LABEL_TEST, "NotifyBrightnessManagerScreenPowerStatus002 function start!"); 1160 uint32_t displayId = 0; 1161 uint32_t screenPowerStatus = 3; // 3 represent the POWER_STATUS_OFF 1162 uint32_t result = DisplayPowerMgrClient::GetInstance().NotifyBrightnessManagerScreenPowerStatus(displayId, 1163 screenPowerStatus); 1164 const uint32_t FAILED_RESULT = 0; 1165 EXPECT_EQ(result, FAILED_RESULT); 1166 DISPLAY_HILOGI(LABEL_TEST, "NotifyBrightnessManagerScreenPowerStatus002 function end!"); 1167 } 1168 } // namespace