1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "display_manager_lite.h"
18 #include "screen_manager_lite.h"
19 #include "mock_display_manager_adapter_lite.h"
20 #include "singleton_mocker.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace Rosen {
27 using Mocker = SingletonMocker<DisplayManagerAdapterLite, MockDisplayManagerAdapterLite>;
28
29 class DisplayLitePowerUnitTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 void SetUp() override;
34 void TearDown() override;
35 static inline DisplayId defaultId_ = 0;
36 static inline uint32_t brightnessLevel_ = 80;
37 static inline ScreenPowerState initialPowerState_;
38 static inline DisplayState initialState_;
39 };
40
SetUpTestCase()41 void DisplayLitePowerUnitTest::SetUpTestCase()
42 {
43 }
44
TearDownTestCase()45 void DisplayLitePowerUnitTest::TearDownTestCase()
46 {
47 }
48
SetUp()49 void DisplayLitePowerUnitTest::SetUp()
50 {
51 initialPowerState_ = ScreenManagerLite::GetInstance().GetScreenPower(defaultId_);
52 initialState_ = DisplayManagerLite::GetInstance().GetDisplayState(defaultId_);
53 }
54
TearDown()55 void DisplayLitePowerUnitTest::TearDown()
56 {
57 ScreenManagerLite::GetInstance().SetScreenPowerForAll(initialPowerState_, PowerStateChangeReason::POWER_BUTTON);
58 DisplayStateCallback callback;
59 DisplayManagerLite::GetInstance().SetDisplayState(initialState_, callback);
60 }
61
62 namespace {
63 /**
64 * @tc.name: wake_up_begin_001
65 * @tc.desc: call WakeUpBegin and check return value
66 * @tc.type: FUNC
67 */
68 HWTEST_F(DisplayLitePowerUnitTest, wake_up_begin_001, Function | SmallTest | Level2)
69 {
70 Mocker m;
71 EXPECT_CALL(m.Mock(), WakeUpBegin(PowerStateChangeReason::POWER_BUTTON)).Times(1).WillOnce(Return(true));;
72 bool ret = DisplayManagerLite::GetInstance().WakeUpBegin(PowerStateChangeReason::POWER_BUTTON);
73 ASSERT_EQ(true, ret);
74
75 EXPECT_CALL(m.Mock(), WakeUpBegin(PowerStateChangeReason::POWER_BUTTON)).Times(1).WillOnce(Return(false));;
76 ret = DisplayManagerLite::GetInstance().WakeUpBegin(PowerStateChangeReason::POWER_BUTTON);
77 ASSERT_EQ(false, ret);
78 }
79
80 /**
81 * @tc.name: wake_up_end_001
82 * @tc.desc: call WakeUpEnd and check return value
83 * @tc.type: FUNC
84 */
85 HWTEST_F(DisplayLitePowerUnitTest, wake_up_end_001, Function | SmallTest | Level2)
86 {
87 Mocker m;
88 EXPECT_CALL(m.Mock(), WakeUpEnd()).Times(1).WillOnce(Return(true));
89 bool ret = DisplayManagerLite::GetInstance().WakeUpEnd();
90 ASSERT_EQ(true, ret);
91
92 EXPECT_CALL(m.Mock(), WakeUpEnd()).Times(1).WillOnce(Return(false));
93 ret = DisplayManagerLite::GetInstance().WakeUpEnd();
94 ASSERT_EQ(false, ret);
95 }
96
97 /**
98 * @tc.name: suspend_begin_001
99 * @tc.desc: call SuspendBegin and check return value
100 * @tc.type: FUNC
101 */
102 HWTEST_F(DisplayLitePowerUnitTest, suspend_begin_001, Function | SmallTest | Level2)
103 {
104 Mocker m;
105 EXPECT_CALL(m.Mock(), SuspendBegin(PowerStateChangeReason::POWER_BUTTON)).Times(1).WillOnce(Return(true));;
106 bool ret = DisplayManagerLite::GetInstance().SuspendBegin(PowerStateChangeReason::POWER_BUTTON);
107 ASSERT_EQ(true, ret);
108
109 EXPECT_CALL(m.Mock(), SuspendBegin(PowerStateChangeReason::POWER_BUTTON)).Times(1).WillOnce(Return(false));;
110 ret = DisplayManagerLite::GetInstance().SuspendBegin(PowerStateChangeReason::POWER_BUTTON);
111 ASSERT_EQ(false, ret);
112 }
113
114 /**
115 * @tc.name: suspend_end_001
116 * @tc.desc: call SuspendEnd and check return value
117 * @tc.type: FUNC
118 */
119 HWTEST_F(DisplayLitePowerUnitTest, suspend_end_001, Function | SmallTest | Level2)
120 {
121 Mocker m;
122 EXPECT_CALL(m.Mock(), SuspendEnd()).Times(1).WillOnce(Return(true));
123 bool ret = DisplayManagerLite::GetInstance().SuspendEnd();
124 ASSERT_EQ(true, ret);
125
126 EXPECT_CALL(m.Mock(), SuspendEnd()).Times(1).WillOnce(Return(false));
127 ret = DisplayManagerLite::GetInstance().SuspendEnd();
128 ASSERT_EQ(false, ret);
129 }
130
131 /**
132 * @tc.name: set_screen_brightness_001
133 * @tc.desc: Call SetScreenBrightness with a valid value and check the GetScreenBrightness return value
134 * @tc.type: FUNC
135 */
136 HWTEST_F(DisplayLitePowerUnitTest, set_screen_brightness_001, Function | MediumTest | Level2)
137 {
138 bool ret = DisplayManagerLite::GetInstance().SetScreenBrightness(defaultId_, brightnessLevel_);
139 ASSERT_EQ(true, ret);
140 }
141
142 /**
143 * @tc.name: SetSpecifiedScreenPower
144 * @tc.desc: test SetSpecifiedScreenPower
145 * @tc.type: FUNC
146 */
147 HWTEST_F(DisplayLitePowerUnitTest, set_specified_screen_power_001, Function | SmallTest | Level2)
148 {
149 ScreenPowerState state = ScreenPowerState{0};
150 PowerStateChangeReason reason = PowerStateChangeReason{0};
151 bool ret = ScreenManagerLite::GetInstance().SetSpecifiedScreenPower(0, state, reason);
152 ASSERT_TRUE(ret);
153 }
154
155 /**
156 * @tc.name: set_screen_power_for_all_001
157 * @tc.desc: Call SetScreenPowerForAll with valid value and check the GetScreenPower return value
158 * @tc.type: FUNC
159 */
160 HWTEST_F(DisplayLitePowerUnitTest, set_screen_power_for_all_001, Function | MediumTest | Level2)
161 {
162 SingletonMocker<ScreenManagerAdapterLite, MockScreenManagerAdapterLite> m;
163 EXPECT_CALL(m.Mock(), GetScreenPower(_)).Times(1).WillOnce(Return(ScreenPowerState::POWER_OFF));
164 EXPECT_CALL(m.Mock(), SetScreenPowerForAll(_, PowerStateChangeReason::POWER_BUTTON))
165 .Times(1).WillOnce(Return(true));
166
167 bool ret = ScreenManagerLite::GetInstance().SetScreenPowerForAll(ScreenPowerState::POWER_OFF,
168 PowerStateChangeReason::POWER_BUTTON);
169 ASSERT_EQ(true, ret);
170
171 ScreenPowerState state = ScreenManagerLite::GetInstance().GetScreenPower(defaultId_);
172 ASSERT_EQ(state, ScreenPowerState::POWER_OFF);
173 }
174
175 /**
176 * @tc.name: set_display_state_001
177 * @tc.desc: Call SetDisplayState with valid value and check the GetDisplayState return value
178 * @tc.type: FUNC
179 */
180 HWTEST_F(DisplayLitePowerUnitTest, set_display_state_001, Function | MediumTest | Level2)
181 {
182 DisplayState stateToSet = (initialState_ == DisplayState::OFF ? DisplayState::ON : DisplayState::OFF);
183 Mocker m;
184 EXPECT_CALL(m.Mock(), RegisterDisplayManagerAgent(_, DisplayManagerAgentType::DISPLAY_STATE_LISTENER))
185 .Times(1).WillOnce(Return(DMError::DM_OK));
186 EXPECT_CALL(m.Mock(), SetDisplayState(stateToSet)).Times(1).WillOnce(Return(true));
__anone04161b80202(DisplayState state) 187 DisplayStateCallback callback = [](DisplayState state) {};
188 bool ret = DisplayManagerLite::GetInstance().SetDisplayState(stateToSet, callback);
189 ASSERT_EQ(true, ret);
190
191 EXPECT_CALL(m.Mock(), GetDisplayState(defaultId_)).Times(1).WillOnce(Return(stateToSet));
192 DisplayState state = DisplayManagerLite::GetInstance().GetDisplayState(defaultId_);
193 ASSERT_EQ(state, stateToSet);
194 }
195
196 /**
197 * @tc.name: set_display_state_002
198 * @tc.desc: Call SetDisplayState with invalid callback and check the GetDisplayState return value
199 * @tc.type: FUNC
200 */
201 HWTEST_F(DisplayLitePowerUnitTest, set_display_state_002, Function | MediumTest | Level2)
202 {
203 Mocker m;
204 EXPECT_CALL(m.Mock(), SetDisplayState(_)).Times(0);
205 DisplayState stateToSet = (initialState_ == DisplayState::OFF ? DisplayState::ON : DisplayState::OFF);
206 bool ret = DisplayManagerLite::GetInstance().SetDisplayState(stateToSet, nullptr);
207 ASSERT_EQ(false, ret);
208 }
209 }
210 }
211 }