1 /*
2 * Copyright (c) 2021-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 "power_mgr_service_test.h"
17
18 #include <csignal>
19 #include <iostream>
20
21 #include <if_system_ability_manager.h>
22 #include <ipc_skeleton.h>
23 #include <iservice_registry.h>
24 #include <string_ex.h>
25 #include <system_ability_definition.h>
26
27 #include "power_common.h"
28 #include "power_mgr_client.h"
29 #include "power_mgr_service.h"
30
31 using namespace testing::ext;
32 using namespace OHOS::PowerMgr;
33 using namespace OHOS;
34 using namespace std;
35
SetUpTestCase(void)36 void PowerMgrServiceTest::SetUpTestCase(void)
37 {
38 }
39
TearDownTestCase(void)40 void PowerMgrServiceTest::TearDownTestCase(void)
41 {
42 }
43
SetUp(void)44 void PowerMgrServiceTest::SetUp(void)
45 {
46 }
47
TearDown(void)48 void PowerMgrServiceTest::TearDown(void)
49 {
50 }
51
52 namespace {
53 /**
54 * @tc.name: PowerMgrService01
55 * @tc.desc: Test PowerMgrService service ready.
56 * @tc.type: FUNC
57 */
58 HWTEST_F (PowerMgrServiceTest, PowerMgrService001, TestSize.Level0)
59 {
60 sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
61 ASSERT_TRUE(sam != nullptr) << "PowerMgrService01 fail to get GetSystemAbilityManager";
62 sptr<IRemoteObject> remoteObject_ = sam->CheckSystemAbility(POWER_MANAGER_SERVICE_ID);
63 ASSERT_TRUE(remoteObject_ != nullptr) << "GetSystemAbility failed.";
64 }
65
66 /**
67 * @tc.name: PowerMgrService002
68 * @tc.desc: Test PowerMgrService Start and stop.
69 * @tc.type: FUNC
70 */
71 HWTEST_F (PowerMgrServiceTest, PowerMgrService002, TestSize.Level0)
72 {
73 if (false) {
74 auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
75 ASSERT_TRUE(pmsTest_ != nullptr) << "PowerMgrService02 fail to get PowerMgrService";
76 ASSERT_TRUE(!pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ is ready";
77 pmsTest_->OnStart();
78 ASSERT_TRUE(pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ is not ready";
79 pmsTest_->OnStop();
80 ASSERT_TRUE(!pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ stop fail";
81 pmsTest_->OnStart();
82 ASSERT_TRUE(pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ is not ready";
83 pmsTest_->OnStop();
84 ASSERT_TRUE(!pmsTest_->IsServiceReady()) << "SetUpTestCase pmsTest_ stop fail";
85 }
86 }
87
88 /**
89 * @tc.name: PowerMgrService003
90 * @tc.desc: Test RunningLock Deconstructor unlock
91 * @tc.type: FUNC
92 */
93 HWTEST_F (PowerMgrServiceTest, PowerMgrService003, TestSize.Level0)
94 {
95 auto& powerMgrClient = PowerMgrClient::GetInstance();
96 auto runningLock1 = powerMgrClient.CreateRunningLock("runninglock1", RunningLockType::RUNNINGLOCK_SCREEN);
97 ASSERT_TRUE(runningLock1 != nullptr);
98
99 runningLock1->Lock();
100 ASSERT_TRUE(runningLock1->IsUsed()) << "runningLock1->IsUsed() != true";
101 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService003 end.");
102 }
103
104 /**
105 * @tc.name: PowerMgrService005
106 * @tc.desc: Test overrideScreenOffTime in screenon
107 * @tc.type: FUNC
108 */
109 HWTEST_F (PowerMgrServiceTest, PowerMgrService005, TestSize.Level0)
110 {
111 auto& powerMgrClient = PowerMgrClient::GetInstance();
112 powerMgrClient.WakeupDevice();
113 EXPECT_TRUE(powerMgrClient.OverrideScreenOffTime(1000));
114 sleep(2);
115 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrService005: Prepare Fail, Screen is ON.";
116 EXPECT_TRUE(powerMgrClient.RestoreScreenOffTime());
117 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService005 end.");
118 }
119
120 /**
121 * @tc.name: PowerMgrService006
122 * @tc.desc: Test overrideScreenOffTime in screenon
123 * @tc.type: FUNC
124 */
125 HWTEST_F (PowerMgrServiceTest, PowerMgrService006, TestSize.Level0)
126 {
127 auto& powerMgrClient = PowerMgrClient::GetInstance();
128 powerMgrClient.WakeupDevice();
129 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0));
130 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService006: Prepare Fail, Screen is ON.";
131
132 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService006 end.");
133 }
134
135 /**
136 * @tc.name: PowerMgrService007
137 * @tc.desc: Test overrideScreenOffTime in screenon
138 * @tc.type: FUNC
139 */
140 HWTEST_F (PowerMgrServiceTest, PowerMgrService007, TestSize.Level0)
141 {
142 auto& powerMgrClient = PowerMgrClient::GetInstance();
143 powerMgrClient.WakeupDevice();
144 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1));
145 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService007: Prepare Fail, Screen is OFF.";
146
147 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService007 end.");
148 }
149
150 /**
151 * @tc.name: PowerMgrService008
152 * @tc.desc: Test overrideScreenOffTime in screenoff
153 * @tc.type: FUNC
154 */
155 HWTEST_F (PowerMgrServiceTest, PowerMgrService008, TestSize.Level0)
156 {
157 auto& powerMgrClient = PowerMgrClient::GetInstance();
158 powerMgrClient.SuspendDevice();
159 EXPECT_TRUE(powerMgrClient.OverrideScreenOffTime(1000));
160 powerMgrClient.WakeupDevice();
161 sleep(2);
162 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrService008: Prepare Fail, Screen is ON.";
163 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService008 end.");
164 }
165
166 /**
167 * @tc.name: PowerMgrService009
168 * @tc.desc: Test overrideScreenOffTime in screenoff
169 * @tc.type: FUNC
170 */
171 HWTEST_F (PowerMgrServiceTest, PowerMgrService009, TestSize.Level0)
172 {
173 auto& powerMgrClient = PowerMgrClient::GetInstance();
174 powerMgrClient.SuspendDevice();
175 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0));
176 powerMgrClient.WakeupDevice();
177 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService009: Prepare Fail, Screen is ON.";
178
179 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService009 end.");
180 }
181
182 /**
183 * @tc.name: PowerMgrService010
184 * @tc.desc: Test overrideScreenOffTime in screenoff
185 * @tc.type: FUNC
186 */
187 HWTEST_F (PowerMgrServiceTest, PowerMgrService010, TestSize.Level0)
188 {
189 auto& powerMgrClient = PowerMgrClient::GetInstance();
190 powerMgrClient.SuspendDevice();
191 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1));
192 powerMgrClient.WakeupDevice();
193 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService010: Prepare Fail, Screen is OFF.";
194
195 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService010 end.");
196 }
197
198 /**
199 * @tc.name: PowerMgrService011
200 * @tc.desc: Test restoreScreenOffTime in screenon
201 * @tc.type: FUNC
202 */
203 HWTEST_F (PowerMgrServiceTest, PowerMgrService011, TestSize.Level0)
204 {
205 auto& powerMgrClient = PowerMgrClient::GetInstance();
206 powerMgrClient.WakeupDevice();
207 EXPECT_TRUE(powerMgrClient.OverrideScreenOffTime(1000));
208 EXPECT_TRUE(powerMgrClient.RestoreScreenOffTime());
209 sleep(2);
210 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService011: Prepare Fail, Screen is OFF.";
211
212 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService011 end.");
213 }
214
215 /**
216 * @tc.name: PowerMgrService012
217 * @tc.desc: Test restoreScreenOffTime in screenon
218 * @tc.type: FUNC
219 */
220 HWTEST_F (PowerMgrServiceTest, PowerMgrService012, TestSize.Level0)
221 {
222 auto& powerMgrClient = PowerMgrClient::GetInstance();
223 powerMgrClient.WakeupDevice();
224 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0));
225 EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime());
226 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService012: Prepare Fail, Screen is OFF.";
227
228 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService012 end.");
229 }
230
231 /**
232 * @tc.name: PowerMgrService013
233 * @tc.desc: Test restoreScreenOffTime in screenon
234 * @tc.type: FUNC
235 */
236 HWTEST_F (PowerMgrServiceTest, PowerMgrService013, TestSize.Level0)
237 {
238 auto& powerMgrClient = PowerMgrClient::GetInstance();
239 powerMgrClient.WakeupDevice();
240 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1));;
241 EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime());
242 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService013: Prepare Fail, Screen is OFF.";
243
244 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService013 end.");
245 }
246
247 /**
248 * @tc.name: PowerMgrService014
249 * @tc.desc: Test restoreScreenOffTime in screenoff
250 * @tc.type: FUNC
251 */
252 HWTEST_F (PowerMgrServiceTest, PowerMgrService014, TestSize.Level0)
253 {
254 auto& powerMgrClient = PowerMgrClient::GetInstance();
255 powerMgrClient.SuspendDevice();
256 EXPECT_TRUE(powerMgrClient.OverrideScreenOffTime(1000));
257 EXPECT_TRUE(powerMgrClient.RestoreScreenOffTime());
258 powerMgrClient.WakeupDevice();
259 sleep(2);
260 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService014: Prepare Fail, Screen is OFF.";
261
262 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService014 end.");
263 }
264
265 /**
266 * @tc.name: PowerMgrService015
267 * @tc.desc: Test restoreScreenOffTime in screenoff
268 * @tc.type: FUNC
269 */
270 HWTEST_F (PowerMgrServiceTest, PowerMgrService015, TestSize.Level0)
271 {
272 auto& powerMgrClient = PowerMgrClient::GetInstance();
273 powerMgrClient.SuspendDevice();
274 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0));
275 EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime());
276 powerMgrClient.WakeupDevice();
277 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService015: Prepare Fail, Screen is OFF.";
278
279 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService015 end.");
280 }
281
282 /**
283 * @tc.name: PowerMgrService016
284 * @tc.desc: Test restoreScreenOffTime in screenoff
285 * @tc.type: FUNC
286 */
287 HWTEST_F (PowerMgrServiceTest, PowerMgrService016, TestSize.Level0)
288 {
289 auto& powerMgrClient = PowerMgrClient::GetInstance();
290 powerMgrClient.SuspendDevice();
291 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1));
292 EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime());
293 powerMgrClient.WakeupDevice();
294 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService016: Prepare Fail, Screen is OFF.";
295
296 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService016 end.");
297 }
298
299 /**
300 * @tc.name: PowerMgrService017
301 * @tc.desc: Test Dump
302 * @tc.type: FUNC
303 * @tc.require: issueI650CX
304 */
305 HWTEST_F(PowerMgrServiceTest, PowerMgrService017, TestSize.Level2)
306 {
307 auto& powerMgrClient = PowerMgrClient::GetInstance();
308 std::vector<std::string> dumpArgs {};
309 std::string expectedDebugInfo = "Power manager dump options";
310 std::string actualDebugInfo = powerMgrClient.Dump(dumpArgs);
311 auto index = actualDebugInfo.find(expectedDebugInfo);
312 EXPECT_TRUE(index != string::npos);
313 }
314
315 /**
316 * @tc.name: PowerMgrService018
317 * @tc.desc: Test IsStandby
318 * @tc.type: FUNC
319 * @tc.require: issueI7QHBE
320 */
321 HWTEST_F(PowerMgrServiceTest, PowerMgrService018, TestSize.Level2)
322 {
323 auto& powerMgrClient = PowerMgrClient::GetInstance();
324 bool standby = false;
325 EXPECT_EQ(powerMgrClient.IsStandby(standby), PowerErrors::ERR_OK);
326 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService018 end.");
327 }
328 }
329