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 "shutdown_client_test.h"
17
18 #include <condition_variable>
19 #include <future>
20 #include <mutex>
21 #include "power_log.h"
22 #include "power_mgr_client.h"
23 #include "power_mgr_service.h"
24 #include "shutdown/shutdown_client.h"
25
26 namespace OHOS {
27 namespace PowerMgr {
28 namespace UnitTest {
29 namespace {
30 MessageParcel g_reply;
31 MessageOption g_option;
32 bool g_isOnAsyncShutdown = false;
33 bool g_isOnSyncShutdown = false;
34 bool g_isOnTakeOverShutdown = false;
35 bool g_isOnTakeOverHibernate = false;
36 bool g_isOnAsyncShutdownOrReboot = false;
37 bool g_isOnSyncShutdownOrReboot = false;
38 }
39 using namespace testing::ext;
40
SetUpTestCase()41 void ShutdownClientTest::SetUpTestCase()
42 {
43 }
44
TearDownTestCase()45 void ShutdownClientTest::TearDownTestCase()
46 {
47 }
48
SetUp()49 void ShutdownClientTest::SetUp()
50 {
51 g_isOnAsyncShutdown = false;
52 g_isOnSyncShutdown = false;
53 g_isOnTakeOverShutdown = false;
54 }
55
TearDown()56 void ShutdownClientTest::TearDown()
57 {}
58
OnAsyncShutdown()59 void ShutdownClientTest::AsyncShutdownCallback::OnAsyncShutdown()
60 {
61 g_isOnAsyncShutdown = true;
62 }
63
OnAsyncShutdownOrReboot(bool isReboot)64 void ShutdownClientTest::AsyncShutdownCallback::OnAsyncShutdownOrReboot(bool isReboot)
65 {
66 g_isOnAsyncShutdownOrReboot = isReboot;
67 }
68
OnSyncShutdown()69 void ShutdownClientTest::SyncShutdownCallback::OnSyncShutdown()
70 {
71 g_isOnSyncShutdown = true;
72 }
73
OnSyncShutdownOrReboot(bool isReboot)74 void ShutdownClientTest::SyncShutdownCallback::OnSyncShutdownOrReboot(bool isReboot)
75 {
76 g_isOnSyncShutdownOrReboot = isReboot;
77 }
78
OnTakeOverShutdown(const TakeOverInfo & info)79 bool ShutdownClientTest::TakeOverShutdownCallback::OnTakeOverShutdown(const TakeOverInfo& info)
80 {
81 g_isOnTakeOverShutdown = true;
82 return true;
83 }
84
OnTakeOverHibernate(const TakeOverInfo & info)85 bool ShutdownClientTest::TakeOverShutdownCallback::OnTakeOverHibernate(const TakeOverInfo& info)
86 {
87 g_isOnTakeOverHibernate = true;
88 return true;
89 }
90
91 /**
92 * @tc.name: RegisterShutdownCallback001
93 * @tc.desc: Test RegisterShutdownCallback
94 * @tc.type: FUNC
95 */
96 HWTEST_F(ShutdownClientTest, RegisterShutdownCallback001, TestSize.Level0)
97 {
98 POWER_HILOGI(LABEL_TEST, "RegisterShutdownCallback001 function start!");
99 sptr<IAsyncShutdownCallback> asyncShutdownCallback = new AsyncShutdownCallback();
100 sptr<ISyncShutdownCallback> syncShutdownCallback = new SyncShutdownCallback();
101 sptr<ITakeOverShutdownCallback> takeOverShutdownCallback = new TakeOverShutdownCallback();
102 auto& shutdownClient = ShutdownClient::GetInstance();
103 shutdownClient.RegisterShutdownCallback(asyncShutdownCallback);
104 shutdownClient.RegisterShutdownCallback(syncShutdownCallback);
105 shutdownClient.RegisterShutdownCallback(takeOverShutdownCallback);
106
107 auto& powerMgrClient = PowerMgrClient::GetInstance();
108 powerMgrClient.RebootDevice("RegisterShutdownCallback001");
109 EXPECT_FALSE(g_isOnAsyncShutdown);
110 EXPECT_FALSE(g_isOnSyncShutdown);
111 EXPECT_TRUE(g_isOnTakeOverShutdown);
112
113 powerMgrClient.RebootDeviceForDeprecated("RegisterShutdownCallback001");
114 EXPECT_FALSE(g_isOnAsyncShutdown);
115 EXPECT_FALSE(g_isOnSyncShutdown);
116 EXPECT_TRUE(g_isOnTakeOverShutdown);
117
118 powerMgrClient.ShutDownDevice("RegisterShutdownCallback001");
119 EXPECT_FALSE(g_isOnAsyncShutdown);
120 EXPECT_FALSE(g_isOnSyncShutdown);
121 EXPECT_TRUE(g_isOnTakeOverShutdown);
122 POWER_HILOGI(LABEL_TEST, "RegisterShutdownCallback001 function end!");
123 }
124
125 /**
126 * @tc.name: UnRegisterShutdownCallback001
127 * @tc.desc: Test UnRegisterShutdownCallback
128 * @tc.type: FUNC
129 */
130 HWTEST_F(ShutdownClientTest, UnRegisterShutdownCallback001, TestSize.Level0)
131 {
132 POWER_HILOGI(LABEL_TEST, "UnRegisterShutdownCallback001 function start!");
133 sptr<IAsyncShutdownCallback> asyncShutdownCallback = new AsyncShutdownCallback();
134 sptr<ISyncShutdownCallback> syncShutdownCallback = new SyncShutdownCallback();
135 sptr<ITakeOverShutdownCallback> takeOverShutdownCallback = new TakeOverShutdownCallback();
136 auto& shutdownClient = ShutdownClient::GetInstance();
137 shutdownClient.RegisterShutdownCallback(asyncShutdownCallback);
138 shutdownClient.UnRegisterShutdownCallback(asyncShutdownCallback);
139 shutdownClient.RegisterShutdownCallback(syncShutdownCallback);
140 shutdownClient.UnRegisterShutdownCallback(syncShutdownCallback);
141 shutdownClient.RegisterShutdownCallback(takeOverShutdownCallback);
142 shutdownClient.UnRegisterShutdownCallback(takeOverShutdownCallback);
143
144 auto& powerMgrClient = PowerMgrClient::GetInstance();
145 powerMgrClient.RebootDevice("UnRegisterShutdownCallback001");
146 EXPECT_FALSE(g_isOnAsyncShutdown);
147 EXPECT_FALSE(g_isOnSyncShutdown);
148 EXPECT_TRUE(g_isOnTakeOverShutdown);
149
150 powerMgrClient.ShutDownDevice("UnRegisterShutdownCallback001");
151 EXPECT_FALSE(g_isOnAsyncShutdown);
152 EXPECT_FALSE(g_isOnSyncShutdown);
153 EXPECT_TRUE(g_isOnTakeOverShutdown);
154 POWER_HILOGI(LABEL_TEST, "UnRegisterShutdownCallback001 function end!");
155 }
156
157 /**
158 * @tc.name: AsyncShutdownCallbackStub001
159 * @tc.desc: Test AsyncShutdownCallbackStub
160 * @tc.type: FUNC
161 * @tc.require: issueI7MNRN
162 */
163 HWTEST_F(ShutdownClientTest, AsyncShutdownCallbackStub001, TestSize.Level0)
164 {
165 POWER_HILOGI(LABEL_TEST, "AsyncShutdownCallbackStub001 function start!");
166 uint32_t code = 0;
167 MessageParcel data;
168 AsyncShutdownCallback asyncShutdownCallback;
169 asyncShutdownCallback.AsyncShutdownCallbackStub::OnAsyncShutdown();
170 EXPECT_FALSE(g_isOnAsyncShutdown);
171 data.WriteInterfaceToken(AsyncShutdownCallback::GetDescriptor());
172 int32_t ret = asyncShutdownCallback.OnRemoteRequest(code, data, g_reply, g_option);
173 EXPECT_EQ(ret, ERR_OK);
174 POWER_HILOGI(LABEL_TEST, "AsyncShutdownCallbackStub001 function end!");
175 }
176
177 /**
178 * @tc.name: SyncShutdownCallbackStub001
179 * @tc.desc: Test SyncShutdownCallbackStub
180 * @tc.type: FUNC
181 * @tc.require: issueI7MNRN
182 */
183 HWTEST_F(ShutdownClientTest, SyncShutdownCallbackStub001, TestSize.Level0)
184 {
185 POWER_HILOGI(LABEL_TEST, "SyncShutdownCallbackStub001 function start!");
186 uint32_t code = 0;
187 MessageParcel data;
188 SyncShutdownCallback syncShutdownCallback;
189 syncShutdownCallback.SyncShutdownCallbackStub::OnSyncShutdown();
190 EXPECT_FALSE(g_isOnSyncShutdown);
191 data.WriteInterfaceToken(SyncShutdownCallback::GetDescriptor());
192 int32_t ret = syncShutdownCallback.OnRemoteRequest(code, data, g_reply, g_option);
193 EXPECT_EQ(ret, ERR_OK);
194 POWER_HILOGI(LABEL_TEST, "SyncShutdownCallbackStub001 function end!");
195 }
196
197 /**
198 * @tc.name: TakeOverShutdownCallbackStub001
199 * @tc.desc: Test TakeOverShutdownCallbackStub
200 * @tc.type: FUNC
201 * @tc.require:
202 */
203 HWTEST_F(ShutdownClientTest, TakeOverShutdownCallbackStub001, TestSize.Level0)
204 {
205 POWER_HILOGI(LABEL_TEST, "TakeOverShutdownCallbackStub001 function start!");
206 uint32_t code = 0; // CMD_ON_TAKEOVER_SHUTDOWN
207 MessageParcel data;
208 MessageParcel reply;
209 TakeOverInfo info("TakeOverShutdownCallbackStub001", false);
210 TakeOverShutdownCallback takeOverShutdownCallback;
211 data.WriteInterfaceToken(TakeOverShutdownCallback::GetDescriptor());
212 data.WriteParcelable(&info);
213 int32_t ret = takeOverShutdownCallback.OnRemoteRequest(code, data, reply, g_option);
214 EXPECT_EQ(ret, ERR_OK);
215 EXPECT_EQ(reply.ReadBool(), true);
216 EXPECT_EQ(g_isOnTakeOverShutdown, true);
217 bool retVal = takeOverShutdownCallback.TakeOverShutdownCallbackStub::OnTakeOverShutdown(
218 {"TakeOverShutdownCallbackStub001", false});
219 EXPECT_EQ(retVal, false);
220 POWER_HILOGI(LABEL_TEST, "TakeOverShutdownCallbackStub001 function end!");
221 }
222
223 /**
224 * @tc.name: TakeOverShutdownCallbackStub002
225 * @tc.desc: Test TakeOverShutdownCallbackStub
226 * @tc.type: FUNC
227 * @tc.require:
228 */
229 HWTEST_F(ShutdownClientTest, TakeOverShutdownCallbackStub002, TestSize.Level0)
230 {
231 POWER_HILOGI(LABEL_TEST, "TakeOverShutdownCallbackStub002 function start!");
232 uint32_t code = 1; // CMD_ON_TAKEOVER_HIBERNATE
233 MessageParcel data;
234 MessageParcel reply;
235 TakeOverInfo info("TakeOverShutdownCallbackStub002", false);
236 TakeOverShutdownCallback takeOverShutdownCallback;
237 data.WriteInterfaceToken(TakeOverShutdownCallback::GetDescriptor());
238 data.WriteParcelable(&info);
239 int32_t ret = takeOverShutdownCallback.OnRemoteRequest(code, data, reply, g_option);
240 EXPECT_EQ(ret, ERR_OK);
241 EXPECT_EQ(reply.ReadBool(), true);
242 EXPECT_EQ(g_isOnTakeOverHibernate, true);
243 bool retVal = takeOverShutdownCallback.TakeOverShutdownCallbackStub::OnTakeOverHibernate(
244 {"TakeOverShutdownCallbackStub002", false});
245 EXPECT_EQ(retVal, false);
246 POWER_HILOGI(LABEL_TEST, "TakeOverShutdownCallbackStub002 function end!");
247 }
248
249 /**
250 * @tc.name: AsyncShutdownOrRebootCallbackStub001
251 * @tc.desc: Test AsyncShutdownOrRebootCallbackStub
252 * @tc.type: FUNC
253 * @tc.require:
254 */
255 HWTEST_F(ShutdownClientTest, AsyncShutdownOrRebootCallbackStub001, TestSize.Level0)
256 {
257 POWER_HILOGI(LABEL_TEST, "AsyncShutdownOrRebootCallbackStub001 function start!");
258 uint32_t code = 1;
259 MessageParcel data;
260 AsyncShutdownCallback asyncShutdownCallback;
261 asyncShutdownCallback.AsyncShutdownCallbackStub::OnAsyncShutdownOrReboot(true);
262 EXPECT_FALSE(g_isOnAsyncShutdownOrReboot);
263 data.WriteInterfaceToken(AsyncShutdownCallback::GetDescriptor());
264 data.WriteBool(true);
265 int32_t ret = asyncShutdownCallback.OnRemoteRequest(code, data, g_reply, g_option);
266 EXPECT_EQ(ret, ERR_OK);
267 POWER_HILOGI(LABEL_TEST, "AsyncShutdownOrRebootCallbackStub001 function end!");
268 }
269
270 /**
271 * @tc.name: SyncShutdownOrRebootCallbackStub001
272 * @tc.desc: Test SyncShutdownOrRebootCallbackStub
273 * @tc.type: FUNC
274 * @tc.require:
275 */
276 HWTEST_F(ShutdownClientTest, SyncShutdownOrRebootCallbackStub001, TestSize.Level0)
277 {
278 POWER_HILOGI(LABEL_TEST, "SyncShutdownOrRebootCallbackStub001 function start!");
279 uint32_t code = 1;
280 MessageParcel data;
281 SyncShutdownCallback syncShutdownCallback;
282 syncShutdownCallback.SyncShutdownCallbackStub::OnSyncShutdownOrReboot(true);
283 EXPECT_FALSE(g_isOnSyncShutdownOrReboot);
284 data.WriteInterfaceToken(SyncShutdownCallback::GetDescriptor());
285 data.WriteBool(true);
286 int32_t ret = syncShutdownCallback.OnRemoteRequest(code, data, g_reply, g_option);
287 EXPECT_EQ(ret, ERR_OK);
288 POWER_HILOGI(LABEL_TEST, "SyncShutdownOrRebootCallbackStub001 function end!");
289 }
290 } // namespace UnitTest
291 } // namespace PowerMgr
292 } // namespace OHOS
293