1 /*
2 * Copyright (c) 2021-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 #ifdef GTEST
16 #define private public
17 #define protected public
18 #endif
19 #include "display_power_mgr_service_test.h"
20
21 #include <iservice_registry.h>
22 #include <system_ability_definition.h>
23 #include <vector>
24
25 #include "display_power_mgr_client.h"
26 #include "display_log.h"
27 #include "display_xcollie.h"
28 #include "mock_display_power_mgr_proxy.h"
29 #include "mock_display_remote_object.h"
30
31 using namespace testing::ext;
32 using namespace OHOS;
33 using namespace OHOS::DisplayPowerMgr;
34 namespace {
35 sptr<IRemoteObject> g_testRemoteObj;
36 sptr<MockDisplayPowerMgrProxy> g_mockProxy;
37 }
38
SetUp()39 void DisplayPowerMgrServiceTest::SetUp()
40 {
41 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON);
42 g_testRemoteObj = sptr<PowerMgr::MockDisplayRemoteObject>::MakeSptr(u"DisplayPowerMgrServiceTest");
43 g_mockProxy = sptr<MockDisplayPowerMgrProxy>::MakeSptr(g_testRemoteObj);
44 }
45
TearDown()46 void DisplayPowerMgrServiceTest::TearDown()
47 {
48 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF);
49 g_testRemoteObj = nullptr;
50 g_mockProxy = nullptr;
51 }
52
OnDisplayStateChanged(uint32_t displayId,DisplayPowerMgr::DisplayState state,uint32_t reason)53 void DisplayPowerMgrServiceTest::DisplayPowerMgrTestCallback::OnDisplayStateChanged(
54 uint32_t displayId, DisplayPowerMgr::DisplayState state, uint32_t reason)
55 {
56 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrTestCallback::OnDisplayStateChanged");
57 }
58
59 namespace {
60 /**
61 * @tc.name: DisplayPowerMgrService001
62 * @tc.desc: Test DisplayPowerMgrService service ready.
63 * @tc.type: FUNC
64 */
65 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService001, TestSize.Level0)
66 {
67 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService001 function start!");
68 sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
69 EXPECT_TRUE(sam != nullptr) << "DisplayPowerMgrService01 fail to get GetSystemAbilityManager";
70 sptr<IRemoteObject> remoteObject_ = sam->CheckSystemAbility(DISPLAY_MANAGER_SERVICE_ID);
71 EXPECT_TRUE(remoteObject_ != nullptr) << "GetSystemAbility failed.";
72 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService001 function end!");
73 }
74
75 /**
76 * @tc.name: DisplayPowerMgrService002
77 * @tc.desc: Test set screen state off
78 * @tc.type: FUNC
79 */
80 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService002, TestSize.Level0)
81 {
82 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService002 function start!");
83 auto ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF);
84 EXPECT_TRUE(ret);
85 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService002 function end!");
86 }
87
88 /**
89 * @tc.name: DisplayPowerMgrService003
90 * @tc.desc: Test set screen state on
91 * @tc.type: FUNC
92 */
93 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService003, TestSize.Level0)
94 {
95 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService003 function start!");
96 auto ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON);
97 EXPECT_TRUE(ret);
98 auto temp = DisplayPowerMgrClient::GetInstance().SetScreenOnBrightness();
99 EXPECT_TRUE(temp);
100 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService003 function end!");
101 }
102
103 /**
104 * @tc.name: DisplayPowerMgrService004
105 * @tc.desc: Test set screen state dim
106 * @tc.type: FUNC
107 */
108 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService004, TestSize.Level0)
109 {
110 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService004 function start!");
111 auto ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_DIM);
112 EXPECT_TRUE(ret);
113 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService004 function end!");
114 }
115
116 /**
117 * @tc.name: DisplayPowerMgrService005
118 * @tc.desc: Test set screen state suspend
119 * @tc.type: FUNC
120 */
121 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService005, TestSize.Level0)
122 {
123 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService005 function start!");
124 auto ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_SUSPEND);
125 EXPECT_TRUE(ret);
126 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService005 function end!");
127 }
128
129 /**
130 * @tc.name: DisplayPowerMgrService006
131 * @tc.desc: Test set screen state unknown
132 * @tc.type: FUNC
133 */
134 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService006, TestSize.Level0)
135 {
136 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService006 function start!");
137 auto ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_UNKNOWN);
138 EXPECT_TRUE(ret);
139 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService006 function end!");
140 }
141
142 /**
143 * @tc.name: DisplayPowerMgrService007
144 * @tc.desc: Test set screen state on
145 * @tc.type: FUNC
146 */
147 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService007, TestSize.Level0)
148 {
149 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService007 function start!");
150 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF);
151 auto ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON);
152 EXPECT_TRUE(ret);
153 DisplayState state = DisplayPowerMgrClient::GetInstance().GetDisplayState();
154 EXPECT_TRUE(state == DisplayState::DISPLAY_ON);
155 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService007 function end!");
156 }
157
158 /**
159 * @tc.name: DisplayPowerMgrService008
160 * @tc.desc: Test set screen state dim
161 * @tc.type: FUNC
162 */
163 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService008, TestSize.Level0)
164 {
165 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService008 function start!");
166 auto ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_DIM);
167 EXPECT_TRUE(ret);
168 DisplayState state = DisplayPowerMgrClient::GetInstance().GetDisplayState();
169 EXPECT_TRUE(state == DisplayState::DISPLAY_DIM);
170 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService008 function end!");
171 }
172
173 /**
174 * @tc.name: DisplayPowerMgrService009
175 * @tc.desc: Test set screen state off
176 * @tc.type: FUNC
177 */
178 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService009, TestSize.Level0)
179 {
180 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService009 function start!");
181 auto ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF);
182 EXPECT_TRUE(ret);
183 DisplayState state = DisplayPowerMgrClient::GetInstance().GetDisplayState();
184 EXPECT_TRUE(state == DisplayState::DISPLAY_OFF);
185 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService009 function end!");
186 }
187
188 /**
189 * @tc.name: DisplayPowerMgrService010
190 * @tc.desc: Test set screen state suspend
191 * @tc.type: FUNC
192 */
193 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService010, TestSize.Level0)
194 {
195 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService010 function start!");
196 auto ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_SUSPEND);
197 EXPECT_TRUE(ret);
198 DisplayState state = DisplayPowerMgrClient::GetInstance().GetDisplayState();
199 EXPECT_TRUE(state == DisplayState::DISPLAY_SUSPEND);
200 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService010 function end!");
201 }
202
203 /**
204 * @tc.name: DisplayPowerMgrService011
205 * @tc.desc: Test set screen state unknown
206 * @tc.type: FUNC
207 */
208 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService011, TestSize.Level0)
209 {
210 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService011 function start!");
211 auto ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_UNKNOWN);
212 EXPECT_TRUE(ret);
213 DisplayState state = DisplayPowerMgrClient::GetInstance().GetDisplayState();
214 EXPECT_TRUE(state == DisplayState::DISPLAY_UNKNOWN);
215 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService011 function end!");
216 }
217
218 /**
219 * @tc.name: DisplayPowerMgrService012
220 * @tc.desc: Test GetDisplayIds
221 * @tc.type: FUNC
222 */
223 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService012, TestSize.Level0)
224 {
225 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService012 function start!");
226 std::vector<uint32_t> ret = DisplayPowerMgrClient::GetInstance().GetDisplayIds();
227 EXPECT_TRUE(ret.size() != 0);
228 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService012 function end!");
229 }
230
231 /**
232 * @tc.name: DisplayPowerMgrService013
233 * @tc.desc: Test GetMainDisplayId
234 * @tc.type: FUNC
235 */
236 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService013, TestSize.Level0)
237 {
238 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService013 function start!");
239 int32_t ret = DisplayPowerMgrClient::GetInstance().GetMainDisplayId();
240 EXPECT_TRUE(ret == 0);
241 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService013 function end!");
242 }
243
244 /**
245 * @tc.name: DisplayPowerMgrService014
246 * @tc.desc: Test AutoAdjustBrightness
247 * @tc.type: FUNC
248 */
249 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService014, TestSize.Level0)
250 {
251 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService014 function start!");
252 bool ret = DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(true);
253 if (ret) {
254 DISPLAY_HILOGI(LABEL_TEST, "AutoAdjustBrightness: is supported");
255 ret = DisplayPowerMgrClient::GetInstance().AutoAdjustBrightness(false);
256 EXPECT_TRUE(ret);
257 } else {
258 DISPLAY_HILOGI(LABEL_TEST, "AutoAdjustBrightness: is not supported");
259 EXPECT_FALSE(ret);
260 }
261 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService014 function end!");
262 }
263
264 /**
265 * @tc.name: DisplayPowerMgrService015
266 * @tc.desc: Test GetError
267 * @tc.type: FUNC
268 */
269 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService015, TestSize.Level0)
270 {
271 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService015 function start!");
272 DisplayErrors error = DisplayPowerMgrClient::GetInstance().GetError();
273 DISPLAY_HILOGI(LABEL_TEST, "get error %{public}d", static_cast<int32_t>(error));
274 EXPECT_TRUE(error == DisplayErrors::ERR_OK);
275 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService015 function end!");
276 }
277
278 /**
279 * @tc.name: DisplayPowerMgrService016
280 * @tc.desc: Test RegisterCallback(Input callback is nullptr, function return false)
281 * @tc.type: FUNC
282 * @tc.require: issueI63PTF
283 */
284 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService016, TestSize.Level0)
285 {
286 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService016 function start!");
287 bool result = DisplayPowerMgrClient::GetInstance().RegisterCallback(nullptr);
288 EXPECT_EQ(result, false);
289 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService016 function end!");
290 }
291
292 /**
293 * @tc.name: DisplayPowerMgrService017
294 * @tc.desc: Test OverrideDisplayOffDelay para
295 * @tc.type: FUNC
296 */
297 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService017, TestSize.Level0)
298 {
299 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService017 function start!");
300 bool ret = DisplayPowerMgrClient::GetInstance().OverrideDisplayOffDelay(0);
301 EXPECT_FALSE(ret);
302 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService017 function end!");
303 }
304
305 /**
306 * @tc.name: DisplayPowerMgrService018
307 * @tc.desc: Test prohibitting writing delay screen off time in screen off state
308 * @tc.type: FUNC
309 */
310 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService018, TestSize.Level0)
311 {
312 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService018 function start!");
313 DisplayState State = DisplayPowerMgrClient::GetInstance().GetDisplayState();
314 if (State != DisplayState::DISPLAY_OFF) {
315 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF);
316 }
317 uint32_t delayTime = 10; //delay time is 10ms
318 bool ret = DisplayPowerMgrClient::GetInstance().OverrideDisplayOffDelay(delayTime);
319 EXPECT_FALSE(ret);
320 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService018 function end!");
321 }
322
323 /**
324 * @tc.name: DisplayPowerMgrService019
325 * @tc.desc: Test srceen delay off
326 * @tc.type: FUNC
327 */
328 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService019, TestSize.Level0)
329 {
330 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService019 function start!");
331 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON);
332 uint32_t delayTime = 10; //delay time is 10ms
333 DisplayPowerMgrClient::GetInstance().OverrideDisplayOffDelay(delayTime);
334 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF);
335 DisplayState delayState = DisplayPowerMgrClient::GetInstance().GetDisplayState();
336 EXPECT_TRUE(delayState == DisplayState::DISPLAY_DELAY_OFF);
337 //Callback for waiting window
338 int sleepTime = 3; // sleep time is 3s
339 sleep(sleepTime);
340 DisplayState offState = DisplayPowerMgrClient::GetInstance().GetDisplayState();
341 EXPECT_TRUE(offState == DisplayState::DISPLAY_OFF);
342 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService019 function end!");
343 }
344
345 /**
346 * @tc.name: DisplayPowerMgrService020
347 * @tc.desc: Test srceen delay off interrupt
348 * @tc.type: FUNC
349 */
350 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService020, TestSize.Level0)
351 {
352 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService020 function start!");
353 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON);
354 uint32_t delayTime = 200; //delay time is 200ms
355 DisplayPowerMgrClient::GetInstance().OverrideDisplayOffDelay(delayTime);
356 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF);
357 int sleepTime = 100000; // sleep time is 100ms
358 usleep(sleepTime);
359 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON);
360 sleepTime = 300000; // sleep time is 300ms
361 usleep(sleepTime);
362 DisplayState onState = DisplayPowerMgrClient::GetInstance().GetDisplayState();
363 EXPECT_TRUE(onState == DisplayState::DISPLAY_ON);
364 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService020 function end!");
365 }
366
367 /**
368 * @tc.name: DisplayPowerMgrService021
369 * @tc.desc: Test set coordinated and set display state
370 * @tc.type: FUNC
371 * @tc.require: issueI8JBT4
372 */
373 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService021, TestSize.Level0)
374 {
375 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService021 function start!");
376 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF);
377 int sleepTime = 2;
378 //Callback for waiting window 2s
379 sleep(sleepTime);
380 bool coordinated = true;
381 auto ret = DisplayPowerMgrClient::GetInstance().SetCoordinated(coordinated);
382 EXPECT_TRUE(ret);
383 // Prepare test environment.
384 // If the state of display is DISPLAY_ON, change it to DISPLAY_OFF.
385 DisplayPowerMgrClient::GetInstance().SetDisplayState(
386 DisplayState::DISPLAY_OFF, PowerMgr::StateChangeReason::STATE_CHANGE_REASON_APPLICATION);
387 sleep(sleepTime);
388 ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(
389 DisplayState::DISPLAY_ON, PowerMgr::StateChangeReason::STATE_CHANGE_REASON_APPLICATION);
390 EXPECT_TRUE(ret);
391 ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(
392 DisplayState::DISPLAY_OFF, PowerMgr::StateChangeReason::STATE_CHANGE_REASON_APPLICATION);
393 EXPECT_TRUE(ret);
394 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService021 function end!");
395 }
396
397 /**
398 * @tc.name: DisplayPowerMgrService022
399 * @tc.desc: Test set display state in Pre-light the screen
400 * @tc.type: FUNCs
401 * @tc.require: issue#I9AJ1S
402 */
403 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService022, TestSize.Level0)
404 {
405 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService022 function start!");
406 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON);
407 DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF);
408 int sleepTime = 2;
409 //Callback for waiting window 2s
410 sleep(sleepTime);
411 DisplayState currentState = DisplayPowerMgrClient::GetInstance().GetDisplayState();
412 EXPECT_TRUE(currentState == DisplayState::DISPLAY_OFF);
413
414 bool ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON,
415 PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT);
416 EXPECT_FALSE(ret);
417 currentState = DisplayPowerMgrClient::GetInstance().GetDisplayState();
418 EXPECT_TRUE(currentState == DisplayState::DISPLAY_OFF);
419 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService022 function end!");
420 }
421
422 /**
423 * @tc.name: DisplayPowerMgrService023
424 * @tc.desc: Test set display state in Pre-light the screen and auth success
425 * @tc.type: FUNC
426 * @tc.require: issue#I9AJ1S
427 */
428 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService023, TestSize.Level0)
429 {
430 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService023 function start!");
431 bool ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF);
432 int sleepTime = 2;
433 //Callback for waiting window 2s
434 sleep(sleepTime);
435 DisplayState currentState = DisplayPowerMgrClient::GetInstance().GetDisplayState();
436 EXPECT_TRUE(currentState == DisplayState::DISPLAY_OFF);
437
438 ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON,
439 PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS);
440 EXPECT_TRUE(ret);
441 currentState = DisplayPowerMgrClient::GetInstance().GetDisplayState();
442 EXPECT_TRUE(currentState == DisplayState::DISPLAY_ON);
443 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService023 function end!");
444 }
445
446 /**
447 * @tc.name: DisplayPowerMgrService024
448 * @tc.desc: Test set display state in Pre-light the screen and auth failed but screen on
449 * @tc.type: FUNC
450 * @tc.require: issue#I9AJ1S
451 */
452 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService024, TestSize.Level0)
453 {
454 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService024 function start!");
455 bool ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF);
456 int sleepTime = 2;
457 //Callback for waiting window 2s
458 sleep(sleepTime);
459 DisplayState currentState = DisplayPowerMgrClient::GetInstance().GetDisplayState();
460 EXPECT_TRUE(currentState == DisplayState::DISPLAY_OFF);
461
462 ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON,
463 PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON);
464 EXPECT_TRUE(ret);
465 currentState = DisplayPowerMgrClient::GetInstance().GetDisplayState();
466 EXPECT_TRUE(currentState == DisplayState::DISPLAY_ON);
467 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService024 function end!");
468 }
469
470 /**
471 * @tc.name: DisplayPowerMgrService025
472 * @tc.desc: Test set display state in Pre-light the screen and auth failed but screen on
473 * @tc.type: FUNC
474 * @tc.require: issue#I9AJ1S
475 */
476 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService025, TestSize.Level0)
477 {
478 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService025 function start!");
479 bool ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF);
480 int sleepTime = 2;
481 //Callback for waiting window 2s
482 sleep(sleepTime);
483 DisplayState currentState = DisplayPowerMgrClient::GetInstance().GetDisplayState();
484 EXPECT_TRUE(currentState == DisplayState::DISPLAY_OFF);
485
486 ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF,
487 PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF);
488 sleep(sleepTime);
489 EXPECT_FALSE(ret);
490 currentState = DisplayPowerMgrClient::GetInstance().GetDisplayState();
491 EXPECT_TRUE(currentState == DisplayState::DISPLAY_OFF);
492 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService025 function end!");
493 }
494
495 /**
496 * @tc.name: DisplayXCollie001
497 * @tc.desc: Test functions DisplayXCollie default
498 * @tc.type: FUNC
499 */
500 HWTEST_F(DisplayPowerMgrServiceTest, DisplayXCollie001, TestSize.Level1)
501 {
502 DISPLAY_HILOGI(LABEL_TEST, "DisplayXCollie001 function start!");
503 DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDisplayState");
504 EXPECT_FALSE(displayXCollie.isCanceled_.load());
505 displayXCollie.CancelDisplayXCollie();
506 EXPECT_TRUE(displayXCollie.isCanceled_.load());
507 DISPLAY_HILOGI(LABEL_TEST, "DisplayXCollie001 function end!");
508 }
509
510 /**
511 * @tc.name: DisplayXCollie002
512 * @tc.desc: Test functions DisplayXCollie isRecovery = true
513 * @tc.type: FUNC
514 */
515 HWTEST_F(DisplayPowerMgrServiceTest, DisplayXCollie002, TestSize.Level1)
516 {
517 DISPLAY_HILOGI(LABEL_TEST, "DisplayXCollie002 function start!");
518 DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDisplayState", true);
519 EXPECT_FALSE(displayXCollie.isCanceled_.load());
520 displayXCollie.CancelDisplayXCollie();
521 EXPECT_TRUE(displayXCollie.isCanceled_.load());
522 DISPLAY_HILOGI(LABEL_TEST, "DisplayXCollie002 function end!");
523 }
524
525 /**
526 * @tc.name: DisplayXCollie003
527 * @tc.desc: Test functions DisplayXCollie empty logtag
528 * @tc.type: FUNC
529 */
530 HWTEST_F(DisplayPowerMgrServiceTest, DisplayXCollie003, TestSize.Level1)
531 {
532 DISPLAY_HILOGI(LABEL_TEST, "DisplayXCollie003 function start!");
533 std::string emptyString;
534 DisplayXCollie displayXCollie(emptyString, true);
535 EXPECT_FALSE(displayXCollie.isCanceled_.load());
536 displayXCollie.CancelDisplayXCollie();
537 EXPECT_TRUE(displayXCollie.isCanceled_.load());
538 DISPLAY_HILOGI(LABEL_TEST, "DisplayXCollie003 function end!");
539 }
540
541 /**
542 * @tc.name: DisplayPowerMgrClient001
543 * @tc.desc: test SetDisplayState() when proxy return fail
544 * @tc.type: FUNC
545 * @tc.require:
546 */
547 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient001, TestSize.Level0)
548 {
549 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient001 function start!");
550 auto& client = DisplayPowerMgrClient::GetInstance();
551 auto proxy = client.proxy_;
552 client.proxy_ = g_mockProxy;
553 bool ret = client.SetDisplayState(DisplayState::DISPLAY_OFF);
554 client.proxy_ = proxy;
555 EXPECT_FALSE(ret);
556 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient001 function end!");
557 }
558
559 /**
560 * @tc.name: DisplayPowerMgrClient002
561 * @tc.desc: test GetDisplayState() when proxy return fail
562 * @tc.type: FUNC
563 * @tc.require:
564 */
565 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient002, TestSize.Level0)
566 {
567 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient002 function start!");
568 auto& client = DisplayPowerMgrClient::GetInstance();
569 auto proxy = client.proxy_;
570 client.proxy_ = g_mockProxy;
571 auto displayState = client.GetDisplayState();
572 client.proxy_ = proxy;
573 EXPECT_EQ(displayState, DisplayState::DISPLAY_UNKNOWN);
574 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient002 function end!");
575 }
576
577 /**
578 * @tc.name: DisplayPowerMgrClient003
579 * @tc.desc: test GetDisplayIds() when proxy return fail
580 * @tc.type: FUNC
581 * @tc.require:
582 */
583 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient003, TestSize.Level0)
584 {
585 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient003 function start!");
586 auto& client = DisplayPowerMgrClient::GetInstance();
587 auto proxy = client.proxy_;
588 client.proxy_ = g_mockProxy;
589 auto ids = client.GetDisplayIds();
590 client.proxy_ = proxy;
591 EXPECT_TRUE(ids.size() == 0);
592 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient003 function end!");
593 }
594
595 /**
596 * @tc.name: DisplayPowerMgrClient004
597 * @tc.desc: test GetMainDisplayId() when proxy return fail
598 * @tc.type: FUNC
599 * @tc.require:
600 */
601 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient004, TestSize.Level0)
602 {
603 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient004 function start!");
604 auto& client = DisplayPowerMgrClient::GetInstance();
605 auto proxy = client.proxy_;
606 client.proxy_ = g_mockProxy;
607 auto id = client.GetMainDisplayId();
608 client.proxy_ = proxy;
609 EXPECT_EQ(id, OHOS::DisplayPowerMgr::DisplayPowerMgrClient::DEFAULT_MAIN_DISPLAY_ID);
610 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient004 function end!");
611 }
612
613 /**
614 * @tc.name: DisplayPowerMgrClient005
615 * @tc.desc: test SetBrightness() when proxy return fail
616 * @tc.type: FUNC
617 * @tc.require:
618 */
619 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient005, TestSize.Level0)
620 {
621 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient004 function start!");
622 auto& client = DisplayPowerMgrClient::GetInstance();
623 auto proxy = client.proxy_;
624 client.proxy_ = g_mockProxy;
625 const uint32_t SET_BRIGHTNESS = 150;
626 auto result = client.SetBrightness(SET_BRIGHTNESS);
627 client.proxy_ = proxy;
628 EXPECT_FALSE(result);
629 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient005 function end!");
630 }
631
632 /**
633 * @tc.name: DisplayPowerMgrClient006
634 * @tc.desc: test SetMaxBrightness() when proxy return fail
635 * @tc.type: FUNC
636 * @tc.require:
637 */
638 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient006, TestSize.Level0)
639 {
640 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient006 function start!");
641 auto& client = DisplayPowerMgrClient::GetInstance();
642 auto proxy = client.proxy_;
643 client.proxy_ = g_mockProxy;
644 const uint32_t SET_MAX_BRIGHTNESS = 231;
645 auto result = client.SetMaxBrightness(SET_MAX_BRIGHTNESS,
646 OHOS::DisplayPowerMgr::DisplayPowerMgrClient::DEFAULT_MAIN_DISPLAY_ID);
647 client.proxy_ = proxy;
648 EXPECT_FALSE(result);
649 }
650
651 /**
652 * @tc.name: DisplayPowerMgrClient007
653 * @tc.desc: test SetMaxBrightnessNit() when proxy return fail
654 * @tc.type: FUNC
655 * @tc.require:
656 */
657 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient007, TestSize.Level0)
658 {
659 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient006 function start!");
660 auto& client = DisplayPowerMgrClient::GetInstance();
661 auto proxy = client.proxy_;
662 client.proxy_ = g_mockProxy;
663 const uint32_t SET_MAX_BRIGHTNESS = 231;
664 auto result = client.SetMaxBrightnessNit(SET_MAX_BRIGHTNESS,
665 OHOS::DisplayPowerMgr::DisplayPowerMgrClient::DEFAULT_MAIN_DISPLAY_ID);
666 client.proxy_ = proxy;
667 EXPECT_FALSE(result);
668 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient007 function end!");
669 }
670
671 /**
672 * @tc.name: DisplayPowerMgrClient008
673 * @tc.desc: test SetMaxBrightnessNit() when proxy return fail
674 * @tc.type: FUNC
675 * @tc.require:
676 */
677 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient008, TestSize.Level0)
678 {
679 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient008 function start!");
680 auto& client = DisplayPowerMgrClient::GetInstance();
681 auto proxy = client.proxy_;
682 client.proxy_ = g_mockProxy;
683 const double NO_DISCOUNT = 1.00;
684 auto result = client.DiscountBrightness(NO_DISCOUNT);
685 client.proxy_ = proxy;
686 EXPECT_FALSE(result);
687 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient008 function end!");
688 }
689
690 /**
691 * @tc.name: DisplayPowerMgrClient009
692 * @tc.desc: test OverrideBrightness() when proxy return fail
693 * @tc.type: FUNC
694 * @tc.require:
695 */
696 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient009, TestSize.Level0)
697 {
698 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient009 function start!");
699 auto& client = DisplayPowerMgrClient::GetInstance();
700 auto proxy = client.proxy_;
701 client.proxy_ = g_mockProxy;
702 const uint32_t SET_OVERRIDE_BRIGHTNESS = 202;
703 auto result = client.OverrideBrightness(SET_OVERRIDE_BRIGHTNESS);
704 client.proxy_ = proxy;
705 EXPECT_FALSE(result);
706 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient009 function end!");
707 }
708
709 /**
710 * @tc.name: DisplayPowerMgrClient010
711 * @tc.desc: test OverrideDisplayOffDelay() when proxy return fail
712 * @tc.type: FUNC
713 * @tc.require:
714 */
715 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient010, TestSize.Level0)
716 {
717 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient010 function start!");
718 auto& client = DisplayPowerMgrClient::GetInstance();
719 auto proxy = client.proxy_;
720 client.proxy_ = g_mockProxy;
721 const uint32_t OVERRIDE_DELAY_TIME = 200;
722 auto result = client.OverrideDisplayOffDelay(OVERRIDE_DELAY_TIME);
723 client.proxy_ = proxy;
724 EXPECT_FALSE(result);
725 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient010 function end!");
726 }
727
728 /**
729 * @tc.name: DisplayPowerMgrClient011
730 * @tc.desc: test RestoreBrightness() when proxy return fail
731 * @tc.type: FUNC
732 * @tc.require:
733 */
734 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient011, TestSize.Level0)
735 {
736 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient011 function start!");
737 auto& client = DisplayPowerMgrClient::GetInstance();
738 auto proxy = client.proxy_;
739 client.proxy_ = g_mockProxy;
740 auto result = client.RestoreBrightness();
741 client.proxy_ = proxy;
742 EXPECT_FALSE(result);
743 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient011 function end!");
744 }
745
746 /**
747 * @tc.name: DisplayPowerMgrClient012
748 * @tc.desc: test GetBrightness() when proxy return fail
749 * @tc.type: FUNC
750 * @tc.require:
751 */
752 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient012, TestSize.Level0)
753 {
754 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient012 function start!");
755 auto& client = DisplayPowerMgrClient::GetInstance();
756 auto proxy = client.proxy_;
757 client.proxy_ = g_mockProxy;
758 auto brightness = client.GetBrightness();
759 client.proxy_ = proxy;
760 EXPECT_EQ(brightness, OHOS::DisplayPowerMgr::DisplayPowerMgrClient::BRIGHTNESS_OFF);
761 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient012 function end!");
762 }
763
764 /**
765 * @tc.name: DisplayPowerMgrClient013
766 * @tc.desc: test GetDefaultBrightness() when proxy return fail
767 * @tc.type: FUNC
768 * @tc.require:
769 */
770 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient013, TestSize.Level0)
771 {
772 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient013 function start!");
773 auto& client = DisplayPowerMgrClient::GetInstance();
774 auto proxy = client.proxy_;
775 client.proxy_ = g_mockProxy;
776 auto brightness = client.GetBrightness();
777 client.proxy_ = proxy;
778 EXPECT_EQ(brightness, OHOS::DisplayPowerMgr::DisplayPowerMgrClient::BRIGHTNESS_OFF);
779 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient013 function end!");
780 }
781
782 /**
783 * @tc.name: DisplayPowerMgrClient014
784 * @tc.desc: test GetDefaultBrightness() when proxy return fail
785 * @tc.type: FUNC
786 * @tc.require:
787 */
788 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient014, TestSize.Level0)
789 {
790 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient013 function start!");
791 auto& client = DisplayPowerMgrClient::GetInstance();
792 auto proxy = client.proxy_;
793 client.proxy_ = g_mockProxy;
794 auto brightness = client.GetDefaultBrightness();
795 client.proxy_ = proxy;
796 EXPECT_EQ(brightness, 0);
797 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient014 function end!");
798 }
799
800 /**
801 * @tc.name: DisplayPowerMgrClient015
802 * @tc.desc: test GetMaxBrightness() when proxy return fail
803 * @tc.type: FUNC
804 * @tc.require:
805 */
806 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient015, TestSize.Level0)
807 {
808 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient015 function start!");
809 auto& client = DisplayPowerMgrClient::GetInstance();
810 auto proxy = client.proxy_;
811 client.proxy_ = g_mockProxy;
812 auto brightness = client.GetMaxBrightness();
813 client.proxy_ = proxy;
814 EXPECT_EQ(brightness, 0);
815 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient015 function end!");
816 }
817
818 /**
819 * @tc.name: DisplayPowerMgrClient016
820 * @tc.desc: test GetMinBrightness() when proxy return fail
821 * @tc.type: FUNC
822 * @tc.require:
823 */
824 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient016, TestSize.Level0)
825 {
826 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient016 function start!");
827 auto& client = DisplayPowerMgrClient::GetInstance();
828 auto proxy = client.proxy_;
829 client.proxy_ = g_mockProxy;
830 auto brightness = client.GetMinBrightness();
831 client.proxy_ = proxy;
832 EXPECT_EQ(brightness, 0);
833 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient016 function end!");
834 }
835
836 /**
837 * @tc.name: DisplayPowerMgrClient017
838 * @tc.desc: test AdjustBrightness() when proxy return fail
839 * @tc.type: FUNC
840 * @tc.require:
841 */
842 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient017, TestSize.Level0)
843 {
844 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient017 function start!");
845 auto& client = DisplayPowerMgrClient::GetInstance();
846 auto proxy = client.proxy_;
847 client.proxy_ = g_mockProxy;
848 const uint32_t ADJUST_BRIGHTNESS = 200;
849 auto ret = client.AdjustBrightness(OHOS::DisplayPowerMgr::DisplayPowerMgrClient::DEFAULT_MAIN_DISPLAY_ID,
850 ADJUST_BRIGHTNESS);
851 client.proxy_ = proxy;
852 EXPECT_FALSE(ret);
853 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient017 function end!");
854 }
855
856 /**
857 * @tc.name: DisplayPowerMgrClient018
858 * @tc.desc: test AutoAdjustBrightness() when proxy return fail
859 * @tc.type: FUNC
860 * @tc.require:
861 */
862 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient018, TestSize.Level0)
863 {
864 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient018 function start!");
865 auto& client = DisplayPowerMgrClient::GetInstance();
866 auto proxy = client.proxy_;
867 client.proxy_ = g_mockProxy;
868 auto ret = client.AutoAdjustBrightness(true);
869 client.proxy_ = proxy;
870 EXPECT_FALSE(ret);
871 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient018 function end!");
872 }
873
874 /**
875 * @tc.name: DisplayPowerMgrClient019
876 * @tc.desc: test IsAutoAdjustBrightness() when proxy return fail
877 * @tc.type: FUNC
878 * @tc.require:
879 */
880 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient019, TestSize.Level0)
881 {
882 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient019 function start!");
883 auto& client = DisplayPowerMgrClient::GetInstance();
884 auto proxy = client.proxy_;
885 client.proxy_ = g_mockProxy;
886 auto ret = client.IsAutoAdjustBrightness();
887 client.proxy_ = proxy;
888 EXPECT_FALSE(ret);
889 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient019 function end!");
890 }
891
892 /**
893 * @tc.name: DisplayPowerMgrClient020
894 * @tc.desc: test BoostBrightness() when proxy return fail
895 * @tc.type: FUNC
896 * @tc.require:
897 */
898 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient020, TestSize.Level0)
899 {
900 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient020 function start!");
901 auto& client = DisplayPowerMgrClient::GetInstance();
902 auto proxy = client.proxy_;
903 client.proxy_ = g_mockProxy;
904 const uint32_t BOOST_TIMEOUT_MS = 200;
905 auto ret = client.BoostBrightness(BOOST_TIMEOUT_MS);
906 client.proxy_ = proxy;
907 EXPECT_FALSE(ret);
908 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient020 function end!");
909 }
910
911 /**
912 * @tc.name: DisplayPowerMgrClient021
913 * @tc.desc: test CancelBoostBrightness() when proxy return fail
914 * @tc.type: FUNC
915 * @tc.require:
916 */
917 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient021, TestSize.Level0)
918 {
919 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient021 function start!");
920 auto& client = DisplayPowerMgrClient::GetInstance();
921 auto proxy = client.proxy_;
922 client.proxy_ = g_mockProxy;
923 auto ret = client.CancelBoostBrightness();
924 client.proxy_ = proxy;
925 EXPECT_FALSE(ret);
926 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient021 function end!");
927 }
928
929 /**
930 * @tc.name: DisplayPowerMgrClient022
931 * @tc.desc: test GetDeviceBrightness() when proxy return fail
932 * @tc.type: FUNC
933 * @tc.require:
934 */
935 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient022, TestSize.Level0)
936 {
937 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient022 function start!");
938 auto& client = DisplayPowerMgrClient::GetInstance();
939 auto proxy = client.proxy_;
940 client.proxy_ = g_mockProxy;
941 auto brightness = client.GetDeviceBrightness();
942 client.proxy_ = proxy;
943 EXPECT_EQ(brightness, OHOS::DisplayPowerMgr::DisplayPowerMgrClient::BRIGHTNESS_OFF);
944 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient022 function end!");
945 }
946
947 /**
948 * @tc.name: DisplayPowerMgrClient023
949 * @tc.desc: test SetCoordinated() when proxy return fail
950 * @tc.type: FUNC
951 * @tc.require:
952 */
953 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient023, TestSize.Level0)
954 {
955 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient023 function start!");
956 auto& client = DisplayPowerMgrClient::GetInstance();
957 auto proxy = client.proxy_;
958 client.proxy_ = g_mockProxy;
959 auto ret = client.SetCoordinated(true);
960 client.proxy_ = proxy;
961 EXPECT_FALSE(ret);
962 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient023 function end!");
963 }
964
965 /**
966 * @tc.name: DisplayPowerMgrClient024
967 * @tc.desc: test SetLightBrightnessThreshold() when proxy return fail
968 * @tc.type: FUNC
969 * @tc.require:
970 */
971 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient024, TestSize.Level0)
972 {
973 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient024 function start!");
974 auto& client = DisplayPowerMgrClient::GetInstance();
975 auto proxy = client.proxy_;
976 client.proxy_ = g_mockProxy;
977 std::vector<int32_t> threshold = {};
978 auto ret = client.SetLightBrightnessThreshold(threshold, nullptr);
979 client.proxy_ = proxy;
980 EXPECT_FALSE(ret);
981 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient024 function end!");
982 }
983
984 /**
985 * @tc.name: DisplayPowerMgrClient025
986 * @tc.desc: test RegisterCallback() when proxy return fail
987 * @tc.type: FUNC
988 * @tc.require:
989 */
990 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient025, TestSize.Level0)
991 {
992 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient025 function start!");
993 auto& client = DisplayPowerMgrClient::GetInstance();
994 auto proxy = client.proxy_;
995 client.proxy_ = g_mockProxy;
996 sptr<IDisplayPowerCallback> callback = new DisplayPowerMgrServiceTest::DisplayPowerMgrTestCallback();
997 auto ret = client.RegisterCallback(callback);
998 client.proxy_ = proxy;
999 EXPECT_FALSE(ret);
1000 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient025 function end!");
1001 }
1002
1003 /**
1004 * @tc.name: DisplayPowerMgrClient026
1005 * @tc.desc: test SetScreenOnBrightness() when proxy return fail
1006 * @tc.type: FUNC
1007 * @tc.require:
1008 */
1009 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient026, TestSize.Level0)
1010 {
1011 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient026 function start!");
1012 auto& client = DisplayPowerMgrClient::GetInstance();
1013 auto proxy = client.proxy_;
1014 client.proxy_ = g_mockProxy;
1015 auto ret = client.SetScreenOnBrightness();
1016 client.proxy_ = proxy;
1017 EXPECT_FALSE(ret);
1018 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient026 function end!");
1019 }
1020
1021 /**
1022 * @tc.name: DisplayPowerMgrClient027
1023 * @tc.desc: test NotifyBrightnessManagerScreenPowerStatus() when proxy return fail
1024 * @tc.type: FUNC
1025 * @tc.require:
1026 */
1027 HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient027, TestSize.Level0)
1028 {
1029 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient027 function start!");
1030 auto& client = DisplayPowerMgrClient::GetInstance();
1031 auto proxy = client.proxy_;
1032 client.proxy_ = g_mockProxy;
1033 auto ret = client.NotifyBrightnessManagerScreenPowerStatus(
1034 OHOS::DisplayPowerMgr::DisplayPowerMgrClient::DEFAULT_MAIN_DISPLAY_ID,
1035 static_cast<uint32_t>(DisplayState::DISPLAY_ON));
1036 client.proxy_ = proxy;
1037 static constexpr int32_t DEFAULT_VALUE = -1;
1038 EXPECT_EQ(ret, DEFAULT_VALUE);
1039 DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient027 function end!");
1040 }
1041 } // namespace
1042