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 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.ShutDownDevice("RegisterShutdownCallback001");
114 EXPECT_FALSE(g_isOnAsyncShutdown);
115 EXPECT_FALSE(g_isOnSyncShutdown);
116 EXPECT_TRUE(g_isOnTakeOverShutdown);
117 POWER_HILOGI(LABEL_TEST, "RegisterShutdownCallback001 end");
118 }
119
120 /**
121 * @tc.name: UnRegisterShutdownCallback001
122 * @tc.desc: Test UnRegisterShutdownCallback
123 * @tc.type: FUNC
124 */
125 HWTEST_F(ShutdownClientTest, UnRegisterShutdownCallback001, TestSize.Level0)
126 {
127 POWER_HILOGI(LABEL_TEST, "UnRegisterShutdownCallback001 start");
128 sptr<IAsyncShutdownCallback> asyncShutdownCallback = new AsyncShutdownCallback();
129 sptr<ISyncShutdownCallback> syncShutdownCallback = new SyncShutdownCallback();
130 sptr<ITakeOverShutdownCallback> takeOverShutdownCallback = new TakeOverShutdownCallback();
131 auto& shutdownClient = ShutdownClient::GetInstance();
132 shutdownClient.RegisterShutdownCallback(asyncShutdownCallback);
133 shutdownClient.UnRegisterShutdownCallback(asyncShutdownCallback);
134 shutdownClient.RegisterShutdownCallback(syncShutdownCallback);
135 shutdownClient.UnRegisterShutdownCallback(syncShutdownCallback);
136 shutdownClient.RegisterShutdownCallback(takeOverShutdownCallback);
137 shutdownClient.UnRegisterShutdownCallback(takeOverShutdownCallback);
138
139 auto& powerMgrClient = PowerMgrClient::GetInstance();
140 powerMgrClient.RebootDevice("UnRegisterShutdownCallback001");
141 EXPECT_FALSE(g_isOnAsyncShutdown);
142 EXPECT_FALSE(g_isOnSyncShutdown);
143 EXPECT_TRUE(g_isOnTakeOverShutdown);
144
145 powerMgrClient.ShutDownDevice("UnRegisterShutdownCallback001");
146 EXPECT_FALSE(g_isOnAsyncShutdown);
147 EXPECT_FALSE(g_isOnSyncShutdown);
148 EXPECT_TRUE(g_isOnTakeOverShutdown);
149 POWER_HILOGI(LABEL_TEST, "UnRegisterShutdownCallback001 end");
150 }
151
152 /**
153 * @tc.name: AsyncShutdownCallbackStub001
154 * @tc.desc: Test AsyncShutdownCallbackStub
155 * @tc.type: FUNC
156 * @tc.require: issueI7MNRN
157 */
158 HWTEST_F(ShutdownClientTest, AsyncShutdownCallbackStub001, TestSize.Level0)
159 {
160 POWER_HILOGI(LABEL_TEST, "AsyncShutdownCallbackStub001 start");
161 uint32_t code = 0;
162 MessageParcel data;
163 AsyncShutdownCallback asyncShutdownCallback;
164 asyncShutdownCallback.AsyncShutdownCallbackStub::OnAsyncShutdown();
165 EXPECT_FALSE(g_isOnAsyncShutdown);
166 data.WriteInterfaceToken(AsyncShutdownCallback::GetDescriptor());
167 int32_t ret = asyncShutdownCallback.OnRemoteRequest(code, data, g_reply, g_option);
168 EXPECT_EQ(ret, ERR_OK);
169 POWER_HILOGI(LABEL_TEST, "AsyncShutdownCallbackStub001 end");
170 }
171
172 /**
173 * @tc.name: SyncShutdownCallbackStub001
174 * @tc.desc: Test SyncShutdownCallbackStub
175 * @tc.type: FUNC
176 * @tc.require: issueI7MNRN
177 */
178 HWTEST_F(ShutdownClientTest, SyncShutdownCallbackStub001, TestSize.Level0)
179 {
180 POWER_HILOGI(LABEL_TEST, "SyncShutdownCallbackStub001 start");
181 uint32_t code = 0;
182 MessageParcel data;
183 SyncShutdownCallback syncShutdownCallback;
184 syncShutdownCallback.SyncShutdownCallbackStub::OnSyncShutdown();
185 EXPECT_FALSE(g_isOnSyncShutdown);
186 data.WriteInterfaceToken(SyncShutdownCallback::GetDescriptor());
187 int32_t ret = syncShutdownCallback.OnRemoteRequest(code, data, g_reply, g_option);
188 EXPECT_EQ(ret, ERR_OK);
189 POWER_HILOGI(LABEL_TEST, "SyncShutdownCallbackStub001 end");
190 }
191
192 /**
193 * @tc.name: TakeOverShutdownCallbackStub001
194 * @tc.desc: Test TakeOverShutdownCallbackStub
195 * @tc.type: FUNC
196 * @tc.require:
197 */
198 HWTEST_F(ShutdownClientTest, TakeOverShutdownCallbackStub001, TestSize.Level0)
199 {
200 POWER_HILOGI(LABEL_TEST, "TakeOverShutdownCallbackStub001 start");
201 uint32_t code = 0; // CMD_ON_TAKEOVER_SHUTDOWN
202 MessageParcel data;
203 MessageParcel reply;
204 TakeOverInfo info("TakeOverShutdownCallbackStub001", false);
205 TakeOverShutdownCallback takeOverShutdownCallback;
206 data.WriteInterfaceToken(TakeOverShutdownCallback::GetDescriptor());
207 data.WriteParcelable(&info);
208 int32_t ret = takeOverShutdownCallback.OnRemoteRequest(code, data, reply, g_option);
209 EXPECT_EQ(ret, ERR_OK);
210 EXPECT_EQ(reply.ReadBool(), true);
211 EXPECT_EQ(g_isOnTakeOverShutdown, true);
212 bool retVal = takeOverShutdownCallback.TakeOverShutdownCallbackStub::OnTakeOverShutdown(
213 {"TakeOverShutdownCallbackStub001", false});
214 EXPECT_EQ(retVal, false);
215 POWER_HILOGI(LABEL_TEST, "TakeOverShutdownCallbackStub001 end");
216 }
217
218 /**
219 * @tc.name: TakeOverShutdownCallbackStub002
220 * @tc.desc: Test TakeOverShutdownCallbackStub
221 * @tc.type: FUNC
222 * @tc.require:
223 */
224 HWTEST_F(ShutdownClientTest, TakeOverShutdownCallbackStub002, TestSize.Level0)
225 {
226 POWER_HILOGD(LABEL_TEST, "TakeOverShutdownCallbackStub002 start");
227 uint32_t code = 1; // CMD_ON_TAKEOVER_HIBERNATE
228 MessageParcel data;
229 MessageParcel reply;
230 TakeOverInfo info("TakeOverShutdownCallbackStub002", false);
231 TakeOverShutdownCallback takeOverShutdownCallback;
232 data.WriteInterfaceToken(TakeOverShutdownCallback::GetDescriptor());
233 data.WriteParcelable(&info);
234 int32_t ret = takeOverShutdownCallback.OnRemoteRequest(code, data, reply, g_option);
235 EXPECT_EQ(ret, ERR_OK);
236 EXPECT_EQ(reply.ReadBool(), true);
237 EXPECT_EQ(g_isOnTakeOverHibernate, true);
238 bool retVal = takeOverShutdownCallback.TakeOverShutdownCallbackStub::OnTakeOverHibernate(
239 {"TakeOverShutdownCallbackStub002", false});
240 EXPECT_EQ(retVal, false);
241 POWER_HILOGD(LABEL_TEST, "TakeOverShutdownCallbackStub002 end");
242 }
243
244 /**
245 * @tc.name: AsyncShutdownOrRebootCallbackStub001
246 * @tc.desc: Test AsyncShutdownOrRebootCallbackStub
247 * @tc.type: FUNC
248 * @tc.require:
249 */
250 HWTEST_F(ShutdownClientTest, AsyncShutdownOrRebootCallbackStub001, TestSize.Level0)
251 {
252 POWER_HILOGI(LABEL_TEST, "AsyncShutdownOrRebootCallbackStub001 start");
253 uint32_t code = 1;
254 MessageParcel data;
255 AsyncShutdownCallback asyncShutdownCallback;
256 asyncShutdownCallback.AsyncShutdownCallbackStub::OnAsyncShutdownOrReboot(true);
257 EXPECT_FALSE(g_isOnAsyncShutdownOrReboot);
258 data.WriteInterfaceToken(AsyncShutdownCallback::GetDescriptor());
259 data.WriteBool(true);
260 int32_t ret = asyncShutdownCallback.OnRemoteRequest(code, data, g_reply, g_option);
261 EXPECT_EQ(ret, ERR_OK);
262 POWER_HILOGI(LABEL_TEST, "AsyncShutdownOrRebootCallbackStub001 end");
263 }
264
265 /**
266 * @tc.name: SyncShutdownOrRebootCallbackStub001
267 * @tc.desc: Test SyncShutdownOrRebootCallbackStub
268 * @tc.type: FUNC
269 * @tc.require:
270 */
271 HWTEST_F(ShutdownClientTest, SyncShutdownOrRebootCallbackStub001, TestSize.Level0)
272 {
273 POWER_HILOGI(LABEL_TEST, "SyncShutdownOrRebootCallbackStub001 start");
274 uint32_t code = 1;
275 MessageParcel data;
276 SyncShutdownCallback syncShutdownCallback;
277 syncShutdownCallback.SyncShutdownCallbackStub::OnSyncShutdownOrReboot(true);
278 EXPECT_FALSE(g_isOnSyncShutdownOrReboot);
279 data.WriteInterfaceToken(SyncShutdownCallback::GetDescriptor());
280 data.WriteBool(true);
281 int32_t ret = syncShutdownCallback.OnRemoteRequest(code, data, g_reply, g_option);
282 EXPECT_EQ(ret, ERR_OK);
283 POWER_HILOGI(LABEL_TEST, "SyncShutdownOrRebootCallbackStub001 end");
284 }
285 } // namespace UnitTest
286 } // namespace PowerMgr
287 } // namespace OHOS
288