1 /*
2 * Copyright (c) 2025 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 "suspend_takeover_client_test.h"
17
18 #include "power_log.h"
19 #include "power_mgr_client.h"
20 #include "power_mgr_service.h"
21 #include "take_over_callback_ipc_interface_code.h"
22 #include <condition_variable>
23 #include <future>
24 #include <mutex>
25
26 namespace OHOS {
27 namespace PowerMgr {
28 namespace UnitTest {
29 namespace {
30 MessageParcel g_reply;
31 MessageOption g_option;
32 bool g_isTakeOverSuspend = false;
33 } // namespace
34 using namespace testing::ext;
35
SetUpTestCase()36 void SuspendTakeoverTest::SetUpTestCase() {}
37
TearDownTestCase()38 void SuspendTakeoverTest::TearDownTestCase() {}
39
SetUp()40 void SuspendTakeoverTest::SetUp()
41 {
42 g_isTakeOverSuspend = false;
43 }
44
TearDown()45 void SuspendTakeoverTest::TearDown() {}
46
OnTakeOverSuspend(SuspendDeviceType type)47 bool SuspendTakeoverTest::TakeOverSuspendCallback::OnTakeOverSuspend(SuspendDeviceType type)
48 {
49 g_isTakeOverSuspend = true;
50 return true;
51 }
52
53 /**
54 * @tc.name: RegisterSuspendCallback001
55 * @tc.desc: Test RegisterSuspendCallback
56 * @tc.type: FUNC
57 */
58 HWTEST_F(SuspendTakeoverTest, RegisterSuspendTakeoverCallback001, TestSize.Level0)
59 {
60 POWER_HILOGI(LABEL_TEST, "RegisterSuspendTakeoverCallback001 function start!");
61 auto& client = PowerMgrClient::GetInstance();
62 sptr<ITakeOverSuspendCallback> takeOverSuspendCallback = new TakeOverSuspendCallback();
63 client.RegisterSuspendTakeoverCallback(takeOverSuspendCallback, TakeOverSuspendPriority::DEFAULT);
64 client.SuspendDevice();
65 EXPECT_TRUE(g_isTakeOverSuspend);
66 POWER_HILOGI(LABEL_TEST, "RegisterSuspendTakeoverCallback001 function end!");
67 }
68
69 /**
70 * @tc.name: UnRegisterSuspendCallback001
71 * @tc.desc: Test UnRegisterSuspendCallback
72 * @tc.type: FUNC
73 */
74 HWTEST_F(SuspendTakeoverTest, UnRegisterSuspendTakeoverCallback001, TestSize.Level0)
75 {
76 POWER_HILOGI(LABEL_TEST, "UnRegisterSuspendTakeoverCallback001 function start!");
77 auto& client = PowerMgrClient::GetInstance();
78 sptr<ITakeOverSuspendCallback> takeOverSuspendCallback = new TakeOverSuspendCallback();
79 client.RegisterSuspendTakeoverCallback(takeOverSuspendCallback, TakeOverSuspendPriority::DEFAULT);
80 client.UnRegisterSuspendTakeoverCallback(takeOverSuspendCallback);
81 client.SuspendDevice();
82 EXPECT_TRUE(g_isTakeOverSuspend);
83 POWER_HILOGI(LABEL_TEST, "UnRegisterSuspendTakeoverCallback001 function end!");
84 }
85
86 /**
87 * @tc.name: TakeOverSuspendCallbackStub001
88 * @tc.desc: Test TakeOverSuspendCallbackStub
89 * @tc.type: FUNC
90 */
91 HWTEST_F(SuspendTakeoverTest, TakeOverSuspendCallbackStub001, TestSize.Level0)
92 {
93 POWER_HILOGI(LABEL_TEST, "TakeOverSuspendCallbackStub001 function start!");
94 int32_t code = 0; // CMD_ON_TAKEOVER_SUSPEND
95 MessageParcel data;
96 MessageParcel reply;
97
98 TakeOverSuspendCallback takeOverSuspendCallback;
99 SuspendDeviceType type = SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_KEY;
100 data.WriteUint32(static_cast<uint32_t>(type));
101 data.WriteInterfaceToken(TakeOverSuspendCallback::GetDescriptor());
102 int32_t ret = takeOverSuspendCallback.OnRemoteRequest(code, data, reply, g_option);
103 EXPECT_EQ(ret, ERR_OK);
104 EXPECT_EQ(reply.ReadBool(), true);
105 EXPECT_EQ(g_isTakeOverSuspend, true);
106 bool retVal = takeOverSuspendCallback.TakeOverSuspendCallbackStub::OnTakeOverSuspend(
107 SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_KEY);
108 EXPECT_EQ(retVal, false);
109 POWER_HILOGI(LABEL_TEST, "TakeOverSuspendCallbackStub001 function end!");
110 }
111
112 /**
113 * @tc.name: TakeOverSuspendCallbackStub002
114 * @tc.desc: Test TakeOverSuspendCallbackStub
115 * @tc.type: FUNC
116 */
117 HWTEST_F(SuspendTakeoverTest, TakeOverSuspendCallbackStub002, TestSize.Level0)
118 {
119 POWER_HILOGI(LABEL_TEST, "TakeOverSuspendCallbackStub002 function start!");
120 int32_t code = 2; // error code test
121 MessageParcel data;
122 MessageParcel reply;
123
124 TakeOverSuspendCallback takeOverSuspendCallback;
125 SuspendDeviceType type = SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND;
126 data.WriteInterfaceToken(TakeOverSuspendCallback::GetDescriptor());
127 data.WriteUint32(static_cast<uint32_t>(type));
128 int32_t ret = takeOverSuspendCallback.OnRemoteRequest(code, data, reply, g_option);
129 EXPECT_EQ(ret, ERR_OK);
130 EXPECT_EQ(reply.ReadBool(), true);
131 EXPECT_EQ(g_isTakeOverSuspend, true);
132 bool retVal = takeOverSuspendCallback.TakeOverSuspendCallbackStub::OnTakeOverSuspend(
133 SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND);
134 EXPECT_EQ(retVal, false);
135 POWER_HILOGI(LABEL_TEST, "TakeOverSuspendCallbackStub002 function end!");
136 }
137
138 /**
139 * @tc.name: TakeOverSuspendCallbackStub003
140 * @tc.desc: Test TakeOverSuspendCallbackStub::OnTakeOverSuspendCallbackStub
141 * {descripter != remoteDescripter} case
142 * @tc.type: FUNC
143 */
144 HWTEST_F(SuspendTakeoverTest, TakeOverSuspendCallbackStub003, TestSize.Level0)
145 {
146 POWER_HILOGI(LABEL_TEST, "TakeOverSuspendCallbackStub003 function start!");
147 int32_t code = static_cast<uint32_t>(TakeOverSuspendCallbackInterfaceCode::CMD_ON_TAKEOVER_SUSPEND);
148 MessageParcel data;
149 MessageParcel reply;
150 data.WriteUint32(0);
151 data.WriteInterfaceToken(u"test.interface.token");
152 TakeOverSuspendCallback takeOverSuspendCallback;
153 int32_t ret = takeOverSuspendCallback.OnRemoteRequest(code, data, reply, g_option);
154 EXPECT_EQ(ret, E_GET_POWER_SERVICE_FAILED);
155 POWER_HILOGI(LABEL_TEST, "TakeOverSuspendCallbackStub003 function end!");
156 }
157
158 /**
159 * @tc.name: TakeOverSuspendCallbackStub004
160 * @tc.desc: Test TakeOverSuspendCallbackStub::OnTakeOverSuspendCallbackStub
161 * {data.ReadUint32(rawType) == false} case
162 * @tc.type: FUNC
163 */
164 HWTEST_F(SuspendTakeoverTest, TakeOverSuspendCallbackStub004, TestSize.Level0)
165 {
166 POWER_HILOGI(LABEL_TEST, "TakeOverSuspendCallbackStub004 function start!");
167 int32_t code = static_cast<uint32_t>(TakeOverSuspendCallbackInterfaceCode::CMD_ON_TAKEOVER_SUSPEND);
168 MessageParcel data;
169 MessageParcel reply;
170 TakeOverSuspendCallback takeOverSuspendCallback;
171 data.WriteInterfaceToken(TakeOverSuspendCallback::GetDescriptor());
172 int32_t ret = takeOverSuspendCallback.OnRemoteRequest(code, data, reply, g_option);
173 EXPECT_EQ(ret, E_READ_PARCEL_ERROR);
174 POWER_HILOGI(LABEL_TEST, "TakeOverSuspendCallbackStub004 function end!");
175 }
176
177 /**
178 * @tc.name: TakeOverSuspendCallbackStub005
179 * @tc.desc: Test TakeOverSuspendCallbackStub::OnTakeOverSuspendCallbackStub
180 * {data.ReadUint32(rawType), rawType > max} case
181 * @tc.type: FUNC
182 */
183 HWTEST_F(SuspendTakeoverTest, TakeOverSuspendCallbackStub005, TestSize.Level0)
184 {
185 POWER_HILOGI(LABEL_TEST, "TakeOverSuspendCallbackStub005 function start!");
186 int32_t code = static_cast<uint32_t>(TakeOverSuspendCallbackInterfaceCode::CMD_ON_TAKEOVER_SUSPEND);
187 MessageParcel data;
188 MessageParcel reply;
189 TakeOverSuspendCallback takeOverSuspendCallback;
190 data.WriteInterfaceToken(TakeOverSuspendCallback::GetDescriptor());
191 data.WriteUint32(100);
192 int32_t ret = takeOverSuspendCallback.OnRemoteRequest(code, data, reply, g_option);
193 EXPECT_EQ(ret, E_READ_PARCEL_ERROR);
194 POWER_HILOGI(LABEL_TEST, "TakeOverSuspendCallbackStub005 function end!");
195 }
196 } // namespace UnitTest
197 } // namespace PowerMgr
198 } // namespace OHOS
199