1 /* 2 * Copyright (c) 2022-2023 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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_EQ(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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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: fun is 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 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness001: fun is end"); 414 } 415 416 /** 417 * @tc.name: DisplayPowerMgrOverrideBrightness002 418 * @tc.desc: Test RestoreBrightness after OverrideBrightness 419 * @tc.type: FUNC 420 */ 421 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness002, TestSize.Level0) 422 { 423 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness002: fun is start"); 424 const uint32_t SET_BRIGHTNESS = 104; 425 const uint32_t OVERRIDE_BRIGHTNESS = 255; 426 const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 427 bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 428 usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness 429 EXPECT_TRUE(ret); 430 ret = DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BRIGHTNESS); 431 usleep(DEFAULT_WAITING_TIME); 432 EXPECT_TRUE(ret); 433 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 434 EXPECT_EQ(value, OVERRIDE_BRIGHTNESS); 435 ret = DisplayPowerMgrClient::GetInstance().RestoreBrightness(); // restore 436 usleep(DEFAULT_WAITING_TIME); 437 EXPECT_TRUE(ret); 438 value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 439 EXPECT_EQ(value, SET_BRIGHTNESS); 440 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness002: fun is end"); 441 } 442 443 /** 444 * @tc.name: DisplayPowerMgrOverrideBrightness003 445 * @tc.desc: Test SetBrightness after OverrideBrightness 446 * @tc.type: FUNC 447 */ 448 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness003, TestSize.Level0) 449 { 450 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness003: fun is start"); 451 const uint32_t SET_BRIGHTNESS = 105; 452 const uint32_t OVERRIDE_BRIGHTNESS = 255; 453 bool ret = DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BRIGHTNESS); 454 usleep(DEFAULT_WAITING_TIME); 455 EXPECT_TRUE(ret); 456 ret = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 457 usleep(DEFAULT_WAITING_TIME); 458 EXPECT_FALSE(ret); 459 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 460 EXPECT_EQ(value, OVERRIDE_BRIGHTNESS); 461 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness003: fun is end"); 462 } 463 464 /** 465 * @tc.name: DisplayPowerMgrOverrideBrightness004 466 * @tc.desc: Test RestoreBrightness after not override 467 * @tc.type: FUNC 468 */ 469 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness004, TestSize.Level0) 470 { 471 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness004: fun is start"); 472 const uint32_t SET_BRIGHTNESS = 106; 473 bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 474 usleep(DEFAULT_WAITING_TIME); 475 EXPECT_TRUE(ret); 476 ret = DisplayPowerMgrClient::GetInstance().RestoreBrightness(); 477 EXPECT_FALSE(ret); 478 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 479 EXPECT_EQ(value, SET_BRIGHTNESS); 480 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness004: fun is end"); 481 } 482 483 /** 484 * @tc.name: DisplayPowerMgrOverrideBrightness005 485 * @tc.desc: Test OverrideBrightness off Disable the call 486 * @tc.type: FUNC 487 */ 488 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness005, TestSize.Level0) 489 { 490 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness005: fun is start"); 491 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF); 492 const uint32_t OVERRIDE_BRIGHTNESS = 100; 493 bool isBoost = DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BRIGHTNESS); 494 EXPECT_FALSE(isBoost); 495 bool isRestore = DisplayPowerMgrClient::GetInstance().RestoreBrightness(); 496 EXPECT_FALSE(isRestore); 497 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness005: fun is end"); 498 } 499 500 /** 501 * @tc.name: DisplayPowerMgrOverrideBrightness006 502 * @tc.desc: Test device brightness when override brightness is 256 503 * @tc.type: FUNC 504 * @tc.require: issueI5YZQR 505 */ 506 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness006, TestSize.Level0) 507 { 508 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness006: fun is start"); 509 uint32_t overrideValue = 256; 510 uint32_t brightnessMax = 255; 511 DisplayPowerMgrClient::GetInstance().OverrideBrightness(overrideValue); 512 usleep(DEFAULT_WAITING_TIME); 513 uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 514 EXPECT_EQ(brightnessMax, deviceBrightness); 515 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness006: fun is end"); 516 } 517 518 /** 519 * @tc.name: DisplayPowerMgrOverrideBrightness007 520 * @tc.desc: Test device brightness when override brightness is 0 521 * @tc.type: FUNC 522 * @tc.require: issueI5YZQR 523 */ 524 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness007, TestSize.Level0) 525 { 526 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness007: fun is start"); 527 uint32_t overrideValue = 0; 528 uint32_t brightnessMin = DisplayPowerMgrClient::GetInstance().GetMinBrightness(); 529 EXPECT_TRUE(DisplayPowerMgrClient::GetInstance().OverrideBrightness(overrideValue)); 530 usleep(DEFAULT_WAITING_TIME); 531 uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 532 EXPECT_EQ(brightnessMin, deviceBrightness); 533 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness007: fun is end"); 534 } 535 536 /** 537 * @tc.name: DisplayPowerMgrOverrideBrightness008 538 * @tc.desc: Test device brightness when override brightness is -1 539 * @tc.type: FUNC 540 * @tc.require: issueI5YZQR 541 */ 542 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness008, TestSize.Level0) 543 { 544 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness008: fun is start"); 545 uint32_t overrideValue = -1; 546 uint32_t brightnessMax = 255; 547 EXPECT_TRUE(DisplayPowerMgrClient::GetInstance().OverrideBrightness(overrideValue)); 548 usleep(DEFAULT_WAITING_TIME); 549 uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 550 EXPECT_EQ(brightnessMax, deviceBrightness); 551 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness008: fun is end"); 552 } 553 554 /** 555 * @tc.name: DisplayPowerMgrOverrideBrightness009 556 * @tc.desc: Set brightness after override brightness, then exit override brightness, the 557 * restore brightness should be brightness value of thr current device 558 * @tc.type: FUNC 559 * @tc.require: issueI6ACLX 560 */ 561 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness009, TestSize.Level0) 562 { 563 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness009: fun is start"); 564 const uint32_t OVERRIDE_BRIGHTNESS = 156; 565 const uint32_t SET_BRIGHTNESS = 66; 566 auto currentBrightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); 567 bool ret1 = DisplayPowerMgrClient::GetInstance().SetBrightness(currentBrightness); 568 usleep(DEFAULT_WAITING_TIME); 569 EXPECT_TRUE(ret1); 570 DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BRIGHTNESS); 571 usleep(DEFAULT_WAITING_TIME); 572 bool ret2 = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 573 usleep(DEFAULT_WAITING_TIME); 574 EXPECT_FALSE(ret2); 575 DisplayPowerMgrClient::GetInstance().RestoreBrightness(); 576 usleep(DEFAULT_WAITING_TIME); 577 uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 578 EXPECT_EQ(currentBrightness, deviceBrightness); 579 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness009: fun is end"); 580 } 581 582 /** 583 * @tc.name: DisplayPowerMgrMaxBrightness001 584 * @tc.desc: Test GetMaxBrightness less equals 255 585 * @tc.type: FUNC 586 */ 587 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrMaxBrightness001, TestSize.Level0) 588 { 589 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrMaxBrightness001: fun is start"); 590 uint32_t max = DisplayPowerMgrClient::GetInstance().GetMaxBrightness(); 591 EXPECT_LE(max, 255); 592 bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(max + 100); 593 usleep(DEFAULT_WAITING_TIME); // sleep 100ms, wait for setting update 594 EXPECT_TRUE(ret); 595 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 596 EXPECT_EQ(value, max); 597 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrMaxBrightness001: fun is end"); 598 } 599 600 /** 601 * @tc.name: DisplayPowerMgrMinBrightness001 602 * @tc.desc: Test GetMinBrightness greater equals 0 603 * @tc.type: FUNC 604 */ 605 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrMinBrightness001, TestSize.Level0) 606 { 607 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrMinBrightness001: fun is start"); 608 const uint32_t SET_BRIGHTNESS_VALUE = 0; 609 uint32_t min = DisplayPowerMgrClient::GetInstance().GetMinBrightness(); 610 EXPECT_GE(min, 0); 611 bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS_VALUE); 612 usleep(DEFAULT_WAITING_TIME); // sleep 100ms, wait for setting update 613 EXPECT_TRUE(ret); 614 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 615 EXPECT_EQ(value, min); 616 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrMinBrightness001: fun is end"); 617 } 618 619 /** 620 * @tc.name: DisplayPowerMgrDefaultBrightness001 621 * @tc.desc: Test GetDefaultnBrightness greater equals 0 and less equals 255 622 * @tc.type: FUNC 623 */ 624 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDefaultBrightness001, TestSize.Level0) 625 { 626 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDefaultBrightness001: fun is start"); 627 uint32_t value = DisplayPowerMgrClient::GetInstance().GetDefaultBrightness(); 628 EXPECT_GE(value, 0); 629 EXPECT_LE(value, 255); 630 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrDefaultBrightness001: fun is end"); 631 } 632 633 /** 634 * @tc.name: DisplayPowerMgrBoostBrightnessNormal 635 * @tc.desc: Test BoostBrightness the normal test 636 * @tc.type: FUNC 637 */ 638 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessNormal, TestSize.Level0) 639 { 640 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessNormal: fun is start"); 641 const uint32_t BOOST_TIME = 100; // keep BoostBrightness 100ms 642 bool isSucc = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_TIME); 643 EXPECT_TRUE(isSucc); 644 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessNormal: fun is end"); 645 } 646 647 /** 648 * @tc.name: DisplayPowerMgrBoostBrightnessAbnormal 649 * @tc.desc: Test BoostBrightness the abnormal value 650 * @tc.type: FUNC 651 */ 652 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessAbnormal, TestSize.Level0) 653 { 654 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessAbnormal: fun is start"); 655 const uint32_t BOOST_TIME = -1; 656 bool isSucc = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_TIME); 657 EXPECT_FALSE(isSucc); 658 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessAbnormal: fun is end"); 659 } 660 661 /** 662 * @tc.name: DisplayPowerMgrCancelBoostBrightnessNormal 663 * @tc.desc: Test CancelBoostBrightness the normal test 664 * @tc.type: FUNC 665 */ 666 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrCancelBoostBrightnessNormal, TestSize.Level0) 667 { 668 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrCancelBoostBrightnessNormal: fun is start"); 669 const uint32_t BOOST_TIME = 50000; 670 bool isSucc = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_TIME); 671 EXPECT_TRUE(isSucc); 672 bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); 673 EXPECT_TRUE(isCancel); 674 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrCancelBoostBrightnessNormal: fun is end"); 675 } 676 677 /** 678 * @tc.name: BoostAndOverrideMutuallyExclusive1 679 * @tc.desc: Test BoostBrightness and OverrideBrightness are mutually exclusive 680 * @tc.type: FUNC 681 */ 682 HWTEST_F(DisplayPowerMgrBrightnessTest, BoostAndOverrideMutuallyExclusive1, TestSize.Level0) 683 { 684 DISPLAY_HILOGI(LABEL_TEST, "BoostAndOverrideMutuallyExclusive: fun is start"); 685 const uint32_t BOOST_TIME = 50000; 686 const uint32_t OVERRIDE_BIRGHTNESS = 100; 687 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_TIME); 688 EXPECT_TRUE(isBoost); 689 bool isOverride = DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BIRGHTNESS); 690 EXPECT_FALSE(isOverride); 691 bool isRestore = DisplayPowerMgrClient::GetInstance().RestoreBrightness(); 692 EXPECT_FALSE(isRestore); 693 DISPLAY_HILOGI(LABEL_TEST, "BoostAndOverrideMutuallyExclusive: fun is end"); 694 } 695 696 /** 697 * @tc.name: BoostAndOverrideMutuallyExclusive2 698 * @tc.desc: Test BoostBrightness and OverrideBrightness are mutually exclusive 699 * @tc.type: FUNC 700 */ 701 HWTEST_F(DisplayPowerMgrBrightnessTest, BoostAndOverrideMutuallyExclusive2, TestSize.Level0) 702 { 703 DISPLAY_HILOGI(LABEL_TEST, "BoostAndOverrideMutuallyExclusive2: fun is start"); 704 const uint32_t BOOST_TIME = 50000; 705 const uint32_t OVERRIDE_BIRGHTNESS = 255; 706 bool isOverride = DisplayPowerMgrClient::GetInstance().OverrideBrightness(OVERRIDE_BIRGHTNESS); 707 EXPECT_TRUE(isOverride); 708 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_TIME); 709 EXPECT_FALSE(isBoost); 710 bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); 711 EXPECT_FALSE(isCancel); 712 DISPLAY_HILOGI(LABEL_TEST, "BoostAndOverrideMutuallyExclusive2: fun is end"); 713 } 714 715 /** 716 * @tc.name: DisplayPowerMgrBoostBrightnessTimeout1 717 * @tc.desc: Test BoostBrightness timeout restore system brightness 718 * @tc.type: FUNC 719 */ 720 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessTimeout1, TestSize.Level0) 721 { 722 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessTimeout1: fun is start"); 723 uint32_t beforeValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 724 const uint32_t BOOST_BRIGHTNESS_TIME = 100; 725 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); 726 EXPECT_TRUE(isBoost); 727 const int sleepTime = 200000; 728 usleep(sleepTime); // sleep 200ms, wait for setting update 729 uint32_t currentValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 730 EXPECT_EQ(beforeValue, currentValue); 731 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessTimeout1: fun is end"); 732 } 733 734 /** 735 * @tc.name: DisplayPowerMgrBoostBrightnessTimeout2 736 * @tc.desc: Test BoostBrightness timeout brightness adjustment can be called 737 * @tc.type: FUNC 738 */ 739 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessTimeout2, TestSize.Level0) 740 { 741 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessTimeout2: fun is start"); 742 const uint32_t SET_BRIGHTNESS = 106; 743 const uint32_t BOOST_BRIGHTNESS_TIME = 100; 744 const int sleepTime = (BOOST_BRIGHTNESS_TIME + 50) * 1000; // wait for (100 + 50)ms BoostBrightness timeout 745 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); 746 EXPECT_TRUE(isBoost); 747 usleep(sleepTime); // sleep 100ms, wait for cancel BoostBrightness 748 bool isSet = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 749 usleep(DEFAULT_WAITING_TIME); // sleep 100ms, wait for setting update 750 EXPECT_TRUE(isSet); 751 uint32_t currentValue = DisplayPowerMgrClient::GetInstance().GetBrightness(); 752 EXPECT_EQ(SET_BRIGHTNESS, currentValue); 753 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessTimeout2: fun is end"); 754 } 755 756 /** 757 * @tc.name: DisplayPowerMgrBoostBrightnessCancel1 758 * @tc.desc: Test BoostBrightness Cancel restore system brightness 759 * @tc.type: FUNC 760 */ 761 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessCancel1, TestSize.Level0) 762 { 763 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessCancel1: fun is start"); 764 const uint32_t SET_BRIGHTNESS = 106; 765 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 766 const int32_t SET_SLEEP_TIME = DEFAULT_WAITING_TIME; 767 usleep(SET_SLEEP_TIME); // sleep 200ms, wait for setBrightness 768 const uint32_t BOOST_BRIGHTNESS_TIME = 10000; 769 const int SLEEP_TIME = 100000; 770 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); 771 EXPECT_TRUE(isBoost); 772 bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); 773 EXPECT_TRUE(isCancel); 774 usleep(SLEEP_TIME); // sleep 100ms, wait for cancel BoostBrightness 775 uint32_t currentValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 776 EXPECT_EQ(SET_BRIGHTNESS, currentValue) << "beforeValue: " << SET_BRIGHTNESS << " currentVal: " << currentValue; 777 DISPLAY_HILOGI(LABEL_TEST, "BoostBrightnessCancel1: beforeValue: %{public}d, currentVal: %{public}d", 778 SET_BRIGHTNESS, currentValue); 779 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessCancel1: fun is end"); 780 } 781 782 /** 783 * @tc.name: DisplayPowerMgrBoostBrightnessCancel2 784 * @tc.desc: Test BoostBrightness Cancel brightness adjustment can be called 785 * @tc.type: FUNC 786 */ 787 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessCancel2, TestSize.Level0) 788 { 789 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessCancel2: fun is start"); 790 const uint32_t BOOST_BRIGHTNESS_TIME = 10000; 791 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); 792 EXPECT_TRUE(isBoost); 793 bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); 794 EXPECT_TRUE(isCancel); 795 const uint32_t SET_BRIGHTNESS_VALUE = 111; 796 bool isSet = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS_VALUE); 797 usleep(DEFAULT_WAITING_TIME); // sleep 100ms, wait for setting update 798 EXPECT_TRUE(isSet); 799 uint32_t currentValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 800 EXPECT_EQ(SET_BRIGHTNESS_VALUE, currentValue); 801 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessCancel2: fun is end"); 802 } 803 804 /** 805 * @tc.name: DisplayPowerMgrBoostBrightnessNotAdjust 806 * @tc.desc: Test BoostBrightness do not adjust brightness, but update cachedSettingBrightness 807 * @tc.type: FUNC 808 */ 809 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessNotAdjust, TestSize.Level0) 810 { 811 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessNotAdjust: fun is start"); 812 const uint32_t SET_BRIGHTNESS = 107; 813 const uint32_t BOOST_BRIGHTNESS_TIME = 10000; 814 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 815 usleep(DEFAULT_WAITING_TIME); 816 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); 817 EXPECT_TRUE(isBoost); 818 bool isSet = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 819 usleep(DEFAULT_WAITING_TIME); 820 EXPECT_FALSE(isSet); 821 DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); 822 uint32_t currentValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 823 EXPECT_EQ(SET_BRIGHTNESS, currentValue); 824 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessNotAdjust: fun is end"); 825 } 826 827 /** 828 * @tc.name: DisplayPowerMgrBoostBrightnessScreenOff 829 * @tc.desc: Test BoostBrightness off Disable the call 830 * @tc.type: FUNC 831 */ 832 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessScreenOff, TestSize.Level0) 833 { 834 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessScreenOff: fun is start"); 835 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF); 836 const uint32_t BOOST_BRIGHTNESS_TIME = 10000; 837 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(BOOST_BRIGHTNESS_TIME); 838 EXPECT_FALSE(isBoost); 839 bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); 840 EXPECT_FALSE(isCancel); 841 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessScreenOff: fun is end"); 842 } 843 844 /** 845 * @tc.name: DisplayPowerMgrBoostBrightnessMultipleCalls 846 * @tc.desc: Test BoostBrightness multiple calls 847 * @tc.type: FUNC 848 */ 849 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrBoostBrightnessMultipleCalls, TestSize.Level0) 850 { 851 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessMultipleCalls: fun is start"); 852 const uint32_t SET_BRIGHTNESS = 108; 853 const uint32_t COUNT = 3; 854 const uint32_t TIMEOUT = 100; 855 const uint32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 856 const uint32_t UPDATE_TIME = 20000; 857 for (uint32_t i = 0; i < COUNT; ++i) { 858 bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(TIMEOUT); 859 usleep(UPDATE_TIME); // wait for set newest BoostBrightness time 860 EXPECT_TRUE(isBoost); 861 } 862 // Brightness adjustment is not allowed 863 bool isSet = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 864 EXPECT_FALSE(isSet); 865 // Wait for a timeout 866 usleep(SLEEP_TIME); 867 bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); 868 EXPECT_FALSE(isCancel); 869 const uint32_t SET_BRIGHTNESS_VALUE = 222; 870 isSet = DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS_VALUE); 871 usleep(DEFAULT_WAITING_TIME); 872 EXPECT_TRUE(isSet); 873 uint32_t currentVal = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 874 EXPECT_EQ(SET_BRIGHTNESS_VALUE, currentVal); 875 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBoostBrightnessMultipleCalls: fun is end"); 876 } 877 878 /** 879 * @tc.name: DisplayPowerMgrAdjustBrightness001 880 * @tc.desc: Test AdjustBrightness 881 * @tc.type: FUNC 882 */ 883 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrAdjustBrightness001, TestSize.Level0) 884 { 885 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness001: fun is start"); 886 bool ret = DisplayPowerMgrClient::GetInstance().AdjustBrightness(0, 3000); 887 EXPECT_TRUE(ret); 888 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness001: fun is end"); 889 } 890 891 /** 892 * @tc.name: DisplayPowerMgrAdjustBrightness002 893 * @tc.desc: Test AutoAdjustBrightness 894 * @tc.type: FUNC 895 */ 896 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrAdjustBrightness002, TestSize.Level0) 897 { 898 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness002: fun is start"); 899 bool ret = DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(true); 900 //waiting to find correct isSettingEnable value 901 usleep(50000); 902 if (ret) { 903 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness002: is supported"); 904 ret = DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(false); 905 //waiting to find correct isSettingEnable value 906 usleep(50000); 907 EXPECT_TRUE(ret); 908 } else { 909 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness002: is not supported"); 910 EXPECT_FALSE(ret); 911 } 912 } 913 914 /** 915 * @tc.name: DisplayPowerMgrAdjustBrightness003 916 * @tc.desc: Test IsAutoAdjustBrightness 917 * @tc.type: FUNC 918 * @tc.require: issueI5YZQR 919 */ 920 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrAdjustBrightness003, TestSize.Level0) 921 { 922 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness003: fun is start"); 923 bool ret = DisplayPowerMgrClient::GetInstance().IsAutoAdjustBrightness(); 924 DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(false); 925 //waiting to find correct isSettingEnable value 926 usleep(50000); 927 EXPECT_EQ(DisplayPowerMgrClient::GetInstance().IsAutoAdjustBrightness(), false); 928 DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(ret); 929 //waiting to find correct isSettingEnable value 930 usleep(50000); 931 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrAdjustBrightness003: fun is end"); 932 } 933 934 /** 935 * @tc.name: DisplayPowerMgrScreenBrightnessEquality001 936 * @tc.desc: Test whether the screen brightness is equal after the screen is on and before the screen is off 937 * @tc.type: FUNC 938 * @tc.require: issueI5YZQR 939 */ 940 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrScreenBrightnessEquality001, TestSize.Level0) 941 { 942 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrScreenBrightnessEquality001: fun is start"); 943 uint32_t deviceBrightness1 = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 944 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF); 945 DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(true); 946 //waiting to find correct isSettingEnable value 947 usleep(50000); 948 DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(false); 949 //waiting to find correct isSettingEnable value 950 usleep(50000); 951 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON); 952 uint32_t deviceBrightness2 = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); 953 EXPECT_EQ(deviceBrightness1, deviceBrightness2); 954 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrScreenBrightnessEquality001: fun is end"); 955 } 956 957 /** 958 * @tc.name: DisplayPowerMgrSleepBrightness001 959 * @tc.desc: Test after entering the dim mode, settings brightness to remain unchanged 960 * @tc.type: FUNC 961 * @tc.require: issueI5YZQR 962 */ 963 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSleepBrightness001, TestSize.Level0) 964 { 965 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSleepBrightness001: fun is start"); 966 uint32_t deviceBrightness1 = DisplayPowerMgrClient::GetInstance().GetBrightness(); 967 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_DIM); 968 //waiting to find correct isSettingEnable value 969 usleep(50000); 970 uint32_t deviceBrightness2 = DisplayPowerMgrClient::GetInstance().GetBrightness(); 971 EXPECT_EQ(deviceBrightness1, deviceBrightness2); 972 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON); 973 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSleepBrightness001: fun is end"); 974 } 975 976 /** 977 * @tc.name: DisplayPowerMgrSetLightBrightnessThreshold001 978 * @tc.desc: Test the Function of setting Ambient Light Monitor (success is returned) 979 * @tc.type: FUNC 980 * @tc.require: issueI8ZHFN 981 */ 982 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetLightBrightnessThreshold001, TestSize.Level0) 983 { 984 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetLightBrightnessThreshold001: fun is start"); 985 std::vector<int32_t> threshold = {200, 200, 20}; 986 uint32_t type = 1; 987 bool state = false; 988 const uint32_t SUCCESS_RESULT = 1; 989 sptr<DisplayBrightnessCallbackStub> callback = new DisplayBrightnessCallbackStub(); 990 callback->OnNotifyApsLightBrightnessChange(type, state); 991 uint32_t result = DisplayPowerMgrClient::GetInstance().SetLightBrightnessThreshold(threshold, callback); 992 EXPECT_EQ(result, SUCCESS_RESULT); 993 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetLightBrightnessThreshold001: fun is end"); 994 } 995 996 /** 997 * @tc.name: DisplayPowerMgrSetLightBrightnessThreshold002 998 * @tc.desc: Test the Function of setting Ambient Light Monitor (success is returned) 999 * @tc.type: FUNC 1000 * @tc.require: issueI8ZHFN 1001 */ 1002 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetLightBrightnessThreshold002, TestSize.Level0) 1003 { 1004 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetLightBrightnessThreshold002: fun is start"); 1005 std::vector<int32_t> threshold = {}; 1006 uint32_t type = 1; 1007 bool state = false; 1008 const uint32_t FAILD_RESULT = 0; 1009 sptr<DisplayBrightnessCallbackStub> callback = new DisplayBrightnessCallbackStub(); 1010 callback->OnNotifyApsLightBrightnessChange(type, state); 1011 uint32_t result = DisplayPowerMgrClient::GetInstance().SetLightBrightnessThreshold(threshold, callback); 1012 EXPECT_EQ(result, FAILD_RESULT); 1013 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetLightBrightnessThreshold002: fun is end"); 1014 } 1015 1016 /** 1017 * @tc.name: DisplayPowerMgrSetMaxBrightnessNit001 1018 * @tc.desc: Test if SetMaxBrightness is less than the current screen brightness, 1019 * then turn down the screen brightness to the set value. 1020 * @tc.type: FUNC 1021 */ 1022 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightnessNit001, TestSize.Level0) 1023 { 1024 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightnessNit001: fun is start"); 1025 const uint32_t SET_BRIGHTNESS = 150; // mapping nit = 350 1026 const uint32_t SET_BRIGHTNESS_NIT = 350; 1027 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 1028 const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 1029 usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness 1030 1031 const uint32_t SET_MAX_BRIGHTNESS = 98; // mapping nit = 231 1032 const uint32_t SET_MAX_BRIGHTNESS_NIT = 231; 1033 bool ret = DisplayPowerMgrClient::GetInstance().SetMaxBrightnessNit(SET_MAX_BRIGHTNESS_NIT, 2); 1034 EXPECT_TRUE(ret); 1035 const int32_t SLEEP_TIME_BRIGHTNESS = 10000000; 1036 usleep(SLEEP_TIME_BRIGHTNESS); // sleep 10s, wait for setBrightness 1037 uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); 1038 EXPECT_EQ(SET_MAX_BRIGHTNESS, brightness); 1039 DisplayPowerMgrClient::GetInstance().SetMaxBrightnessNit(SET_BRIGHTNESS_NIT, 1); 1040 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightnessNit001: fun is end"); 1041 } 1042 1043 /** 1044 * @tc.name: DisplayPowerMgrSetMaxBrightnessNit002 1045 * @tc.desc: Test if SetMaxBrightness is higher than the current screen brightness, just set the max range 1046 * @tc.type: FUNC 1047 */ 1048 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightnessNit002, TestSize.Level0) 1049 { 1050 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightnessNit002: fun is start"); 1051 const uint32_t SET_BRIGHTNESS = 150; // mapping nit = 350 1052 const uint32_t SET_BRIGHTNESS_NIT = 350; 1053 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 1054 const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 1055 usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness 1056 1057 const uint32_t SET_MAX_BRIGHTNESS_NIT = 469; // mapping level = 200; 1058 bool ret = DisplayPowerMgrClient::GetInstance().SetMaxBrightnessNit(SET_MAX_BRIGHTNESS_NIT, 2); 1059 EXPECT_TRUE(ret); 1060 const int32_t SLEEP_TIME_BRIGHTNESS = 10000000; 1061 usleep(SLEEP_TIME_BRIGHTNESS); // sleep 10s, wait for setBrightness 1062 uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); 1063 EXPECT_EQ(SET_BRIGHTNESS, brightness); 1064 DisplayPowerMgrClient::GetInstance().SetMaxBrightnessNit(SET_BRIGHTNESS_NIT, 1); 1065 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightnessNit002: fun is end"); 1066 } 1067 1068 /** 1069 * @tc.name: DisplayPowerMgrSetMaxBrightness001 1070 * @tc.desc: Test if SetMaxBrightness is less than the current screen brightness, 1071 * then turn down the screen brightness to the set value. 1072 * @tc.type: FUNC 1073 */ 1074 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightness001, TestSize.Level0) 1075 { 1076 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightness001: fun is start"); 1077 const uint32_t SET_BRIGHTNESS = 150; 1078 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 1079 const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 1080 usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness 1081 1082 const uint32_t SET_MAX_BRIGHTNESS = 98; 1083 bool ret = DisplayPowerMgrClient::GetInstance().SetMaxBrightness((double)SET_MAX_BRIGHTNESS / 255, 2); 1084 EXPECT_TRUE(ret); 1085 const int32_t SLEEP_TIME_BRIGHTNESS = 10000000; 1086 usleep(SLEEP_TIME_BRIGHTNESS); // sleep 10s, wait for setBrightness 1087 uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); 1088 EXPECT_EQ(SET_MAX_BRIGHTNESS, brightness); 1089 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS, 1); 1090 usleep(SLEEP_TIME); 1091 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightness001: fun is end"); 1092 } 1093 1094 /** 1095 * @tc.name: DisplayPowerMgrSetMaxBrightness002 1096 * @tc.desc: Test if SetMaxBrightness is higher than the current screen brightness, just set the max range 1097 * @tc.type: FUNC 1098 */ 1099 HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightness002, TestSize.Level0) 1100 { 1101 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightness002: fun is start"); 1102 const uint32_t SET_BRIGHTNESS = 150; 1103 DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); 1104 const int32_t SLEEP_TIME = DEFAULT_WAITING_TIME; 1105 usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness 1106 1107 const uint32_t SET_MAX_BRIGHTNESS = 200; 1108 bool ret = DisplayPowerMgrClient::GetInstance().SetMaxBrightness((double)SET_MAX_BRIGHTNESS / 255, 2); 1109 EXPECT_TRUE(ret); 1110 const int32_t SLEEP_TIME_BRIGHTNESS = 10000000; 1111 usleep(SLEEP_TIME_BRIGHTNESS); // sleep 10s, wait for setBrightness 1112 uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); 1113 EXPECT_EQ(SET_BRIGHTNESS, brightness); 1114 DisplayPowerMgrClient::GetInstance().SetMaxBrightness(SET_BRIGHTNESS, 1); 1115 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightness002: fun is end"); 1116 } 1117 } // namespace