1 /*
2 * Copyright (c) 2021 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: PowerMgrService004
106 * @tc.desc: Test Reboot
107 * @tc.type: FUNC
108 */
109 HWTEST_F (PowerMgrServiceTest, PowerMgrService004, TestSize.Level0)
110 {
111 if (false) {
112 auto& powerMgrClient = PowerMgrClient::GetInstance();
113 powerMgrClient.RebootDevice("test");
114 }
115 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService004 end.");
116 }
117
118 /**
119 * @tc.name: PowerMgrService005
120 * @tc.desc: Test overrideScreenOffTime in screenon
121 * @tc.type: FUNC
122 */
123 HWTEST_F (PowerMgrServiceTest, PowerMgrService005, TestSize.Level0)
124 {
125 if (false) {
126 auto& powerMgrClient = PowerMgrClient::GetInstance();
127 powerMgrClient.WakeupDevice();
128 EXPECT_TRUE(powerMgrClient.OverrideScreenOffTime(1000));
129 sleep(2);
130 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrService005: Prepare Fail, Screen is ON.";
131 EXPECT_TRUE(powerMgrClient.RestoreScreenOffTime());
132 }
133 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService005 end.");
134 }
135
136 /**
137 * @tc.name: PowerMgrService006
138 * @tc.desc: Test overrideScreenOffTime in screenon
139 * @tc.type: FUNC
140 */
141 HWTEST_F (PowerMgrServiceTest, PowerMgrService006, TestSize.Level0)
142 {
143 auto& powerMgrClient = PowerMgrClient::GetInstance();
144 powerMgrClient.WakeupDevice();
145 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0));
146 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService006: Prepare Fail, Screen is ON.";
147
148 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService006 end.");
149 }
150
151 /**
152 * @tc.name: PowerMgrService007
153 * @tc.desc: Test overrideScreenOffTime in screenon
154 * @tc.type: FUNC
155 */
156 HWTEST_F (PowerMgrServiceTest, PowerMgrService007, TestSize.Level0)
157 {
158 auto& powerMgrClient = PowerMgrClient::GetInstance();
159 powerMgrClient.WakeupDevice();
160 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1));
161 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService007: Prepare Fail, Screen is OFF.";
162
163 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService007 end.");
164 }
165
166 /**
167 * @tc.name: PowerMgrService008
168 * @tc.desc: Test overrideScreenOffTime in screenoff
169 * @tc.type: FUNC
170 */
171 HWTEST_F (PowerMgrServiceTest, PowerMgrService008, TestSize.Level0)
172 {
173 if (false) {
174 auto& powerMgrClient = PowerMgrClient::GetInstance();
175 powerMgrClient.SuspendDevice();
176 EXPECT_TRUE(powerMgrClient.OverrideScreenOffTime(1000));
177 powerMgrClient.WakeupDevice();
178 sleep(2);
179 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerMgrService008: Prepare Fail, Screen is ON.";
180 EXPECT_TRUE(powerMgrClient.RestoreScreenOffTime());
181 }
182 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService008 end.");
183 }
184
185 /**
186 * @tc.name: PowerMgrService009
187 * @tc.desc: Test overrideScreenOffTime in screenoff
188 * @tc.type: FUNC
189 */
190 HWTEST_F (PowerMgrServiceTest, PowerMgrService009, TestSize.Level0)
191 {
192 auto& powerMgrClient = PowerMgrClient::GetInstance();
193 powerMgrClient.SuspendDevice();
194 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0));
195 powerMgrClient.WakeupDevice();
196 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService009: Prepare Fail, Screen is ON.";
197
198 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService009 end.");
199 }
200
201 /**
202 * @tc.name: PowerMgrService010
203 * @tc.desc: Test overrideScreenOffTime in screenoff
204 * @tc.type: FUNC
205 */
206 HWTEST_F (PowerMgrServiceTest, PowerMgrService010, TestSize.Level0)
207 {
208 auto& powerMgrClient = PowerMgrClient::GetInstance();
209 powerMgrClient.SuspendDevice();
210 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1));
211 powerMgrClient.WakeupDevice();
212 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService010: Prepare Fail, Screen is OFF.";
213
214 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService010 end.");
215 }
216
217 /**
218 * @tc.name: PowerMgrService011
219 * @tc.desc: Test restoreScreenOffTime in screenon
220 * @tc.type: FUNC
221 */
222 HWTEST_F (PowerMgrServiceTest, PowerMgrService011, TestSize.Level0)
223 {
224 auto& powerMgrClient = PowerMgrClient::GetInstance();
225 powerMgrClient.WakeupDevice();
226 EXPECT_TRUE(powerMgrClient.OverrideScreenOffTime(1000));
227 EXPECT_TRUE(powerMgrClient.RestoreScreenOffTime());
228 sleep(2);
229 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService011: Prepare Fail, Screen is OFF.";
230
231 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService011 end.");
232 }
233
234 /**
235 * @tc.name: PowerMgrService012
236 * @tc.desc: Test restoreScreenOffTime in screenon
237 * @tc.type: FUNC
238 */
239 HWTEST_F (PowerMgrServiceTest, PowerMgrService012, TestSize.Level0)
240 {
241 auto& powerMgrClient = PowerMgrClient::GetInstance();
242 powerMgrClient.WakeupDevice();
243 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0));
244 EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime());
245 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService012: Prepare Fail, Screen is OFF.";
246
247 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService012 end.");
248 }
249
250 /**
251 * @tc.name: PowerMgrService013
252 * @tc.desc: Test restoreScreenOffTime in screenon
253 * @tc.type: FUNC
254 */
255 HWTEST_F (PowerMgrServiceTest, PowerMgrService013, TestSize.Level0)
256 {
257 auto& powerMgrClient = PowerMgrClient::GetInstance();
258 powerMgrClient.WakeupDevice();
259 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1));;
260 EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime());
261 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService013: Prepare Fail, Screen is OFF.";
262
263 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService013 end.");
264 }
265
266 /**
267 * @tc.name: PowerMgrService014
268 * @tc.desc: Test restoreScreenOffTime in screenoff
269 * @tc.type: FUNC
270 */
271 HWTEST_F (PowerMgrServiceTest, PowerMgrService014, TestSize.Level0)
272 {
273 auto& powerMgrClient = PowerMgrClient::GetInstance();
274 powerMgrClient.SuspendDevice();
275 EXPECT_TRUE(powerMgrClient.OverrideScreenOffTime(1000));
276 EXPECT_TRUE(powerMgrClient.RestoreScreenOffTime());
277 powerMgrClient.WakeupDevice();
278 sleep(2);
279 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService014: Prepare Fail, Screen is OFF.";
280
281 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService014 end.");
282 }
283
284 /**
285 * @tc.name: PowerMgrService015
286 * @tc.desc: Test restoreScreenOffTime in screenoff
287 * @tc.type: FUNC
288 */
289 HWTEST_F (PowerMgrServiceTest, PowerMgrService015, TestSize.Level0)
290 {
291 auto& powerMgrClient = PowerMgrClient::GetInstance();
292 powerMgrClient.SuspendDevice();
293 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(0));
294 EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime());
295 powerMgrClient.WakeupDevice();
296 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService015: Prepare Fail, Screen is OFF.";
297
298 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService015 end.");
299 }
300
301 /**
302 * @tc.name: PowerMgrService016
303 * @tc.desc: Test restoreScreenOffTime in screenoff
304 * @tc.type: FUNC
305 */
306 HWTEST_F (PowerMgrServiceTest, PowerMgrService016, TestSize.Level0)
307 {
308 auto& powerMgrClient = PowerMgrClient::GetInstance();
309 powerMgrClient.SuspendDevice();
310 EXPECT_FALSE(powerMgrClient.OverrideScreenOffTime(-1));
311 EXPECT_FALSE(powerMgrClient.RestoreScreenOffTime());
312 powerMgrClient.WakeupDevice();
313 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerMgrService016: Prepare Fail, Screen is OFF.";
314
315 POWER_HILOGD(LABEL_TEST, "PowerMgrServiceTest::PowerMgrService016 end.");
316 }
317
318 /**
319 * @tc.name: PowerMgrService017
320 * @tc.desc: Test Dump
321 * @tc.type: FUNC
322 * @tc.require: issueI650CX
323 */
324 HWTEST_F(PowerMgrServiceTest, PowerMgrService017, TestSize.Level2)
325 {
326 auto& powerMgrClient = PowerMgrClient::GetInstance();
327 std::vector<std::string> dumpArgs {};
328 std::string expectedDebugInfo = "Power manager dump options";
329 std::string actualDebugInfo = powerMgrClient.Dump(dumpArgs);
330 auto index = actualDebugInfo.find(expectedDebugInfo);
331 EXPECT_TRUE(index != string::npos);
332 }
333 }