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_state_machine_test.h"
17
18 #include <iostream>
19
20 #include <datetime_ex.h>
21 #include <gtest/gtest.h>
22 #include <if_system_ability_manager.h>
23 #include <ipc_skeleton.h>
24 #include <string_ex.h>
25
26 #include "power_common.h"
27 #include "power_mgr_client.h"
28 #include "power_mgr_service.h"
29 #include "power_state_machine.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 PowerStateMachineTest::SetUpTestCase(void)
37 {
38 }
39
TearDownTestCase(void)40 void PowerStateMachineTest::TearDownTestCase(void)
41 {
42 }
43
SetUp(void)44 void PowerStateMachineTest::SetUp(void)
45 {
46 }
47
TearDown(void)48 void PowerStateMachineTest::TearDown(void)
49 {
50 }
51
52 namespace {
53 /**
54 * @tc.name: PowerStateMachine003
55 * @tc.desc: test Suspend Device in proxy
56 * @tc.type: FUNC
57 */
58 HWTEST_F (PowerStateMachineTest, PowerStateMachine003, TestSize.Level0)
59 {
60 POWER_HILOGI(LABEL_TEST, "PowerStateMachine003::fun is start!");
61 sleep(SLEEP_WAIT_TIME_S);
62 GTEST_LOG_(INFO) << "PowerStateMachine003: Suspend Device start.";
63 auto& powerMgrClient = PowerMgrClient::GetInstance();
64
65 // Wakeup Device before test
66 GTEST_LOG_(INFO) << "PowerStateMachine003: Wakeup Device before test.";
67 powerMgrClient.WakeupDevice();
68 sleep(SLEEP_WAIT_TIME_S);
69 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerStateMachine003: Prepare Fail, Screen is OFF.";
70 GTEST_LOG_(INFO) << "PowerStateMachine003: Screen is On, Begin to Suspend Device!";
71
72 powerMgrClient.SuspendDevice();
73
74 sleep(REFRESHACTIVITY_WAIT_TIME_S);
75 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerStateMachine003: Suspend Device Fail, Screen is On";
76
77 POWER_HILOGI(LABEL_TEST, "PowerStateMachine003::fun is end!");
78 GTEST_LOG_(INFO) << "PowerStateMachine003: Suspend Device end.";
79 }
80
81 /**
82 * @tc.name: PowerStateMachine004
83 * @tc.desc: test WakeupDevice(int64_t timeMs) in proxy
84 * @tc.type: FUNC
85 */
86 HWTEST_F (PowerStateMachineTest, PowerStateMachine004, TestSize.Level0)
87 {
88 POWER_HILOGI(LABEL_TEST, "PowerStateMachine004::fun is start!");
89 sleep(SLEEP_WAIT_TIME_S);
90 GTEST_LOG_(INFO) << "PowerStateMachine004: Wakeup Device start.";
91 auto& powerMgrClient = PowerMgrClient::GetInstance();
92
93 // Suspend Device before test
94 GTEST_LOG_(INFO) << "PowerStateMachine004: Suspend Device before test.";
95 powerMgrClient.SuspendDevice();
96 sleep(SLEEP_WAIT_TIME_S);
97 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerStateMachine004: Prepare Fail, Screen is On.";
98 GTEST_LOG_(INFO) << "PowerStateMachine004: Screen is Off, Begin to Wakeup Device!";
99
100 powerMgrClient.WakeupDevice();
101
102 sleep(SLEEP_WAIT_TIME_S);
103 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerStateMachine004: Wakeup Device Fail, Screen is Off";
104
105 POWER_HILOGI(LABEL_TEST, "PowerStateMachine004::fun is end!");
106 GTEST_LOG_(INFO) << "PowerStateMachine004: Wakeup Device end.";
107 }
108
109 /**
110 * @tc.name: PowerStateMachine005
111 * @tc.desc: test IsScreenOn in proxy
112 * @tc.type: FUNC
113 */
114 HWTEST_F (PowerStateMachineTest, PowerStateMachine005, TestSize.Level0)
115 {
116 sleep(SLEEP_WAIT_TIME_S);
117 GTEST_LOG_(INFO) << "PowerStateMachine005: IsScreenOn start.";
118 auto& powerMgrClient = PowerMgrClient::GetInstance();
119
120 for (int i = 0; i < 3; i++) {
121 if (powerMgrClient.IsScreenOn()) {
122 powerMgrClient.SuspendDevice();
123 sleep(SLEEP_WAIT_TIME_S);
124 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerStateMachine005_" << i
125 << ": Suspend Device Fail, Screen is On";
126 } else {
127 powerMgrClient.WakeupDevice();
128 sleep(SLEEP_WAIT_TIME_S);
129 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerStateMachine005_" << i
130 << ": Wakeup Device Fail, Screen is Off";
131 }
132 }
133
134 GTEST_LOG_(INFO) << "PowerStateMachine05: IsScreenOn end.";
135 }
136
137 /**
138 * @tc.name: PowerStateMachine006
139 * @tc.desc: test WakeupDevice(int64_t timeMs, const WakeupDeviceType reason, const std::string& details) in proxy
140 * @tc.type: FUNC
141 */
142 HWTEST_F (PowerStateMachineTest, PowerStateMachine006, TestSize.Level0)
143 {
144 sleep(SLEEP_WAIT_TIME_S);
145 GTEST_LOG_(INFO) << "PowerStateMachine006: Wakeup Device start.";
146 auto& powerMgrClient = PowerMgrClient::GetInstance();
147
148 // Suspend Device before test
149 GTEST_LOG_(INFO) << "PowerStateMachine006: Suspend Device before test.";
150 powerMgrClient.SuspendDevice();
151 sleep(SLEEP_WAIT_TIME_S);
152 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerStateMachine006: Prepare Fail, Screen is On.";
153 GTEST_LOG_(INFO) << "PowerStateMachine006: Screen is Off, Begin to Wakeup Device!";
154
155 // Check illegal para details
156 GTEST_LOG_(INFO) << "PowerStateMachine006: Check illegal para details Begin!";
157 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION);
158 sleep(SLEEP_WAIT_TIME_S);
159 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerStateMachine006: Check details test Fail, Screen is Off.";
160
161 // Suspend Device before test
162 GTEST_LOG_(INFO) << "PowerStateMachine006: Suspend Device before real test.";
163 powerMgrClient.SuspendDevice();
164 sleep(SLEEP_WAIT_TIME_S);
165 EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerStateMachine006: Real test tprepare Fail, Screen is On.";
166 GTEST_LOG_(INFO) << "PowerStateMachine006: Screen is Off, Begin to Real Wakeup Device!";
167
168 powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION);
169
170 sleep(SLEEP_WAIT_TIME_S);
171 EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerStateMachine006: Real Wakeup Device Fail, Screen is Off";
172
173 GTEST_LOG_(INFO) << "PowerStateMachine006: Wakeup Device end.";
174 }
175
176
177 /**
178 * @tc.name: PowerStateMachine007
179 * @tc.desc: test ForceSuspendDevice in proxy
180 * @tc.type: FUNC
181 */
182 HWTEST_F (PowerStateMachineTest, PowerStateMachine007, TestSize.Level2)
183 {
184 sleep(SLEEP_WAIT_TIME_S);
185 GTEST_LOG_(INFO) << "PowerStateMachine007: ForceSuspendDevice start.";
186 auto& powerMgrClient = PowerMgrClient::GetInstance();
187
188 if (false) {
189 powerMgrClient.ForceSuspendDevice();
190 }
191
192 GTEST_LOG_(INFO) << "PowerStateMachine007: ForceSuspendDevice end.";
193 }
194 }
195
OnPowerStateChanged(PowerState state)196 void PowerStateMachineTest::PowerStateTest1Callback::OnPowerStateChanged(PowerState state)
197 {
198 POWER_HILOGD(LABEL_TEST, "PowerStateTest1Callback::OnPowerStateChanged state = %u.",
199 static_cast<uint32_t>(state));
200 }
201
OnPowerStateChanged(PowerState state)202 void PowerStateMachineTest::PowerStateTest2Callback::OnPowerStateChanged(PowerState state)
203 {
204 POWER_HILOGD(LABEL_TEST, "PowerStateTest2Callback::OnPowerStateChanged state = %u.",
205 static_cast<uint32_t>(state));
206 }
207
208 namespace {
209 /**
210 * @tc.name: PowerStateCallback001
211 * @tc.desc: test PowerStateCallback
212 * @tc.type: FUNC
213 */
214 HWTEST_F (PowerStateMachineTest, PowerStateCallback001, TestSize.Level0)
215 {
216 auto& powerMgrClient = PowerMgrClient::GetInstance();
217 sptr<IPowerStateCallback> cb1 = new PowerStateTest1Callback();
218 powerMgrClient.RegisterPowerStateCallback(cb1);
219 POWER_HILOGD(LABEL_TEST, "PowerStateCallback001 1.");
220 {
221 sptr<IPowerStateCallback> cb2 = new PowerStateTest2Callback();
222 powerMgrClient.UnRegisterPowerStateCallback(cb2);
223 POWER_HILOGD(LABEL_TEST, "PowerStateCallback001 2.");
224 powerMgrClient.RegisterPowerStateCallback(cb2);
225 POWER_HILOGD(LABEL_TEST, "PowerStateCallback001 3.");
226 powerMgrClient.RegisterPowerStateCallback(cb2);
227 POWER_HILOGD(LABEL_TEST, "PowerStateCallback001 4.");
228 }
229 powerMgrClient.UnRegisterPowerStateCallback(cb1);
230 POWER_HILOGD(LABEL_TEST, "PowerStateTestCallback::PowerStateCallback001 end.");
231 }
232
233 /**
234 * @tc.name: ShutDownDeviceTest001
235 * @tc.desc: test ShutDownDevice in proxy
236 * @tc.type: FUNC
237 */
238 HWTEST_F (PowerStateMachineTest, ShutDownDeviceTest001, TestSize.Level2)
239 {
240 sleep(SLEEP_WAIT_TIME_S);
241 GTEST_LOG_(INFO) << "ShutDownDeviceTest001: ShutDownDevice start.";
242 auto& powerMgrClient = PowerMgrClient::GetInstance();
243
244 if (false) {
245 powerMgrClient.ShutDownDevice(string("ShutDownDeviceTest001"));
246 }
247
248 GTEST_LOG_(INFO) << "ShutDownDeviceTest001: ShutDownDevice end.";
249 }
250
251 /**
252 * @tc.name: RebootDeviceTest001
253 * @tc.desc: test RebootDevice in proxy
254 * @tc.type: FUNC
255 */
256 HWTEST_F (PowerStateMachineTest, RebootDeviceTest001, TestSize.Level2)
257 {
258 sleep(SLEEP_WAIT_TIME_S);
259 GTEST_LOG_(INFO) << "RebootDeviceTest001: RebootDevice start.";
260 auto& powerMgrClient = PowerMgrClient::GetInstance();
261
262 if (false) {
263 powerMgrClient.RebootDevice(string("RebootDeviceTest001"));
264 }
265
266 GTEST_LOG_(INFO) << "RebootDeviceTest001: RebootDevice end.";
267 }
268 }
269
270
WakeUpthread()271 void PowerStateMachineTest::WakeUpthread()
272 {
273 auto& powerMgrClient = PowerMgrClient::GetInstance();
274 powerMgrClient.WakeupDevice();
275 }
276
Suspendthread()277 void PowerStateMachineTest::Suspendthread()
278 {
279 auto& powerMgrClient = PowerMgrClient::GetInstance();
280 powerMgrClient.SuspendDevice();
281 }
282
Rebootthread()283 void PowerStateMachineTest::Rebootthread()
284 {
285 auto& powerMgrClient = PowerMgrClient::GetInstance();
286 if (false) {
287 powerMgrClient.RebootDevice(string("RebootDeviceTestThread"));
288 }
289 }
290
Shutdownthread()291 void PowerStateMachineTest::Shutdownthread()
292 {
293 auto& powerMgrClient = PowerMgrClient::GetInstance();
294 if (false) {
295 powerMgrClient.ShutDownDevice(string("ShutDownDeviceTestThread"));
296 }
297 }
298