1 /*
2  * Copyright (c) 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 "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_isOnAsyncShutdownOrReboot = false;
36 bool g_isOnSyncShutdownOrReboot = false;
37 }
38 using namespace testing::ext;
39 
SetUpTestCase()40 void ShutdownClientTest::SetUpTestCase()
41 {
42 }
43 
TearDownTestCase()44 void ShutdownClientTest::TearDownTestCase()
45 {
46 }
47 
SetUp()48 void ShutdownClientTest::SetUp()
49 {
50     g_isOnAsyncShutdown = false;
51     g_isOnSyncShutdown = false;
52     g_isOnTakeOverShutdown = false;
53 }
54 
TearDown()55 void ShutdownClientTest::TearDown()
56 {}
57 
OnAsyncShutdown()58 void ShutdownClientTest::AsyncShutdownCallback::OnAsyncShutdown()
59 {
60     g_isOnAsyncShutdown = true;
61 }
62 
OnAsyncShutdownOrReboot(bool isReboot)63 void ShutdownClientTest::AsyncShutdownCallback::OnAsyncShutdownOrReboot(bool isReboot)
64 {
65     g_isOnAsyncShutdownOrReboot = isReboot;
66 }
67 
OnSyncShutdown()68 void ShutdownClientTest::SyncShutdownCallback::OnSyncShutdown()
69 {
70     g_isOnSyncShutdown = true;
71 }
72 
OnSyncShutdownOrReboot(bool isReboot)73 void ShutdownClientTest::SyncShutdownCallback::OnSyncShutdownOrReboot(bool isReboot)
74 {
75     g_isOnSyncShutdownOrReboot = isReboot;
76 }
77 
OnTakeOverShutdown(bool isReboot)78 bool ShutdownClientTest::TakeOverShutdownCallback::OnTakeOverShutdown(bool isReboot)
79 {
80     g_isOnTakeOverShutdown = true;
81     return true;
82 }
83 
84 /**
85  * @tc.name: RegisterShutdownCallback
86  * @tc.desc: Test RegisterShutdownCallback
87  * @tc.type: FUNC
88  */
89 HWTEST_F(ShutdownClientTest, RegisterShutdownCallback001, TestSize.Level0)
90 {
91     POWER_HILOGI(LABEL_TEST, "RegisterShutdownCallback001 start");
92     sptr<IAsyncShutdownCallback> asyncShutdownCallback = new AsyncShutdownCallback();
93     sptr<ISyncShutdownCallback> syncShutdownCallback = new SyncShutdownCallback();
94     sptr<ITakeOverShutdownCallback> takeOverShutdownCallback = new TakeOverShutdownCallback();
95     auto& shutdownClient = ShutdownClient::GetInstance();
96     shutdownClient.RegisterShutdownCallback(asyncShutdownCallback);
97     shutdownClient.RegisterShutdownCallback(syncShutdownCallback);
98     shutdownClient.RegisterShutdownCallback(takeOverShutdownCallback);
99 
100     auto& powerMgrClient = PowerMgrClient::GetInstance();
101     powerMgrClient.RebootDevice("RegisterShutdownCallback001");
102     EXPECT_FALSE(g_isOnAsyncShutdown);
103     EXPECT_FALSE(g_isOnSyncShutdown);
104     EXPECT_TRUE(g_isOnTakeOverShutdown);
105 
106     powerMgrClient.ShutDownDevice("RegisterShutdownCallback001");
107     EXPECT_FALSE(g_isOnAsyncShutdown);
108     EXPECT_FALSE(g_isOnSyncShutdown);
109     EXPECT_TRUE(g_isOnTakeOverShutdown);
110     POWER_HILOGI(LABEL_TEST, "RegisterShutdownCallback001 end");
111 }
112 
113 /**
114  * @tc.name: UnRegisterShutdownCallback
115  * @tc.desc: Test UnRegisterShutdownCallback
116  * @tc.type: FUNC
117  */
118 HWTEST_F(ShutdownClientTest, UnRegisterShutdownCallback002, TestSize.Level0)
119 {
120     POWER_HILOGI(LABEL_TEST, "UnRegisterShutdownCallback002 start");
121     sptr<IAsyncShutdownCallback> asyncShutdownCallback = new AsyncShutdownCallback();
122     sptr<ISyncShutdownCallback> syncShutdownCallback = new SyncShutdownCallback();
123     sptr<ITakeOverShutdownCallback> takeOverShutdownCallback = new TakeOverShutdownCallback();
124     auto& shutdownClient = ShutdownClient::GetInstance();
125     shutdownClient.RegisterShutdownCallback(asyncShutdownCallback);
126     shutdownClient.UnRegisterShutdownCallback(asyncShutdownCallback);
127     shutdownClient.RegisterShutdownCallback(syncShutdownCallback);
128     shutdownClient.UnRegisterShutdownCallback(syncShutdownCallback);
129     shutdownClient.RegisterShutdownCallback(takeOverShutdownCallback);
130     shutdownClient.UnRegisterShutdownCallback(takeOverShutdownCallback);
131 
132     auto& powerMgrClient = PowerMgrClient::GetInstance();
133     powerMgrClient.RebootDevice("UnRegisterShutdownCallback002");
134     EXPECT_FALSE(g_isOnAsyncShutdown);
135     EXPECT_FALSE(g_isOnSyncShutdown);
136     EXPECT_TRUE(g_isOnTakeOverShutdown);
137 
138     powerMgrClient.ShutDownDevice("UnRegisterShutdownCallback002");
139     EXPECT_FALSE(g_isOnAsyncShutdown);
140     EXPECT_FALSE(g_isOnSyncShutdown);
141     EXPECT_TRUE(g_isOnTakeOverShutdown);
142     POWER_HILOGI(LABEL_TEST, "UnRegisterShutdownCallback002 end");
143 }
144 
145 /**
146  * @tc.name: AsyncShutdownCallbackStub
147  * @tc.desc: Test AsyncShutdownCallbackStub
148  * @tc.type: FUNC
149  * @tc.require: issueI7MNRN
150  */
151 HWTEST_F(ShutdownClientTest, AsyncShutdownCallbackStub003, TestSize.Level0)
152 {
153     POWER_HILOGI(LABEL_TEST, "AsyncShutdownCallbackStub003 start");
154     uint32_t code = 0;
155     MessageParcel data;
156     AsyncShutdownCallback asyncShutdownCallback;
157     asyncShutdownCallback.AsyncShutdownCallbackStub::OnAsyncShutdown();
158     EXPECT_FALSE(g_isOnAsyncShutdown);
159     data.WriteInterfaceToken(AsyncShutdownCallback::GetDescriptor());
160     int32_t ret = asyncShutdownCallback.OnRemoteRequest(code, data, g_reply, g_option);
161     EXPECT_EQ(ret, ERR_OK);
162     POWER_HILOGI(LABEL_TEST, "AsyncShutdownCallbackStub003 end");
163 }
164 
165 /**
166  * @tc.name: SyncShutdownCallbackStub
167  * @tc.desc: Test SyncShutdownCallbackStub
168  * @tc.type: FUNC
169  * @tc.require: issueI7MNRN
170  */
171 HWTEST_F(ShutdownClientTest, SyncShutdownCallbackStub004, TestSize.Level0)
172 {
173     POWER_HILOGI(LABEL_TEST, "SyncShutdownCallbackStub004 start");
174     uint32_t code = 0;
175     MessageParcel data;
176     SyncShutdownCallback syncShutdownCallback;
177     syncShutdownCallback.SyncShutdownCallbackStub::OnSyncShutdown();
178     EXPECT_FALSE(g_isOnSyncShutdown);
179     data.WriteInterfaceToken(SyncShutdownCallback::GetDescriptor());
180     int32_t ret = syncShutdownCallback.OnRemoteRequest(code, data, g_reply, g_option);
181     EXPECT_EQ(ret, ERR_OK);
182     POWER_HILOGI(LABEL_TEST, "SyncShutdownCallbackStub004 end");
183 }
184 
185 /**
186  * @tc.name: TakeOverShutdownCallbackStub
187  * @tc.desc: Test TakeOverShutdownCallbackStub
188  * @tc.type: FUNC
189  * @tc.require: issueI7MNRN
190  */
191 HWTEST_F(ShutdownClientTest, TakeOverShutdownCallbackStub005, TestSize.Level0)
192 {
193     POWER_HILOGI(LABEL_TEST, "TakeOverShutdownCallbackStub005 start");
194     uint32_t code = 0;
195     MessageParcel data;
196     TakeOverShutdownCallback takeOverShutdownCallback;
197     data.WriteInterfaceToken(TakeOverShutdownCallback::GetDescriptor());
198     int32_t ret = takeOverShutdownCallback.OnRemoteRequest(code, data, g_reply, g_option);
199     EXPECT_EQ(ret, E_READ_PARCEL_ERROR);
200     bool retVal = takeOverShutdownCallback.TakeOverShutdownCallbackStub::OnTakeOverShutdown(false);
201     EXPECT_EQ(retVal, false);
202     POWER_HILOGI(LABEL_TEST, "TakeOverShutdownCallbackStub005 end");
203 }
204 
205 /**
206  * @tc.name: AsyncShutdownOrRebootCallbackStub
207  * @tc.desc: Test AsyncShutdownOrRebootCallbackStub
208  * @tc.type: FUNC
209  * @tc.require:
210  */
211 HWTEST_F(ShutdownClientTest, AsyncShutdownOrRebootCallbackStub006, TestSize.Level0)
212 {
213     POWER_HILOGI(LABEL_TEST, "AsyncShutdownOrRebootCallbackStub006 start");
214     uint32_t code = 1;
215     MessageParcel data;
216     AsyncShutdownCallback asyncShutdownCallback;
217     asyncShutdownCallback.AsyncShutdownCallbackStub::OnAsyncShutdownOrReboot(true);
218     EXPECT_FALSE(g_isOnAsyncShutdownOrReboot);
219     data.WriteInterfaceToken(AsyncShutdownCallback::GetDescriptor());
220     data.WriteBool(true);
221     int32_t ret = asyncShutdownCallback.OnRemoteRequest(code, data, g_reply, g_option);
222     EXPECT_EQ(ret, ERR_OK);
223     POWER_HILOGI(LABEL_TEST, "AsyncShutdownOrRebootCallbackStub006 end");
224 }
225 
226 /**
227  * @tc.name: SyncShutdownOrRebootCallbackStub
228  * @tc.desc: Test SyncShutdownOrRebootCallbackStub
229  * @tc.type: FUNC
230  * @tc.require:
231  */
232 HWTEST_F(ShutdownClientTest, SyncShutdownOrRebootCallbackStub007, TestSize.Level0)
233 {
234     POWER_HILOGI(LABEL_TEST, "SyncShutdownOrRebootCallbackStub007 start");
235     uint32_t code = 1;
236     MessageParcel data;
237     SyncShutdownCallback syncShutdownCallback;
238     syncShutdownCallback.SyncShutdownCallbackStub::OnSyncShutdownOrReboot(true);
239     EXPECT_FALSE(g_isOnSyncShutdownOrReboot);
240     data.WriteInterfaceToken(SyncShutdownCallback::GetDescriptor());
241     data.WriteBool(true);
242     int32_t ret = syncShutdownCallback.OnRemoteRequest(code, data, g_reply, g_option);
243     EXPECT_EQ(ret, ERR_OK);
244     POWER_HILOGI(LABEL_TEST, "SyncShutdownOrRebootCallbackStub007 end");
245 }
246 } // namespace UnitTest
247 } // namespace PowerMgr
248 } // namespace OHOS