1 /*
2 * Copyright (c) 2022 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 "battery_srv_proxy_mock_test.h"
17 #include "battery_srv_proxy.h"
18 #include "ipc_object_stub.h"
19 #include "mock_remote_object.h"
20 #include "battery_log.h"
21 #include "battery_info.h"
22
23 using namespace testing::ext;
24 using namespace OHOS::HiviewDFX;
25 using namespace OHOS::PowerMgr;
26 using namespace OHOS;
27 using namespace std;
28
29 namespace {
30 std::shared_ptr<BatterySrvProxy> g_proxy;
31 sptr<IRemoteObject> remoteObj;
32 constexpr int32_t INVALID_VALUE = -1;
33 }
34
SetUpTestCase()35 void BatteryProxyMockTest::SetUpTestCase()
36 {
37 #ifdef ENABLE_REMOTE_INTERFACE
38 remoteObj = new MockRemoteObject();
39 #else
40 remoteObj = new IPCObjectStub();
41 #endif
42 g_proxy = std::make_shared<BatterySrvProxy>(remoteObj);
43 }
44
TearDownTestCase()45 void BatteryProxyMockTest::TearDownTestCase()
46 {
47 remoteObj = nullptr;
48 g_proxy = nullptr;
49 }
50
SetUp()51 void BatteryProxyMockTest::SetUp() {}
52
TearDown()53 void BatteryProxyMockTest::TearDown() {}
54
55 namespace {
56 /**
57 * @tc.name: BatteryProxyMockTest_001
58 * @tc.desc: test BatterySrvProxy::GetCapacity() when an exception is raised
59 * @tc.type: FUNC
60 * @tc.require: issueI5X13X
61 */
62 HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_001, TestSize.Level0)
63 {
64 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_001 function start!");
65 int32_t capacity = INVALID_BATT_INT_VALUE;
66 int32_t errCode = g_proxy->GetCapacity(capacity);
67 EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
68 EXPECT_TRUE(capacity == INVALID_BATT_INT_VALUE);
69 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_001 function end!");
70 }
71
72 /**
73 * @tc.name: BatteryProxyMockTest_002
74 * @tc.desc: test BatterySrvProxy::GetChargingStatus() when an exception is raised
75 * @tc.type: FUNC
76 * @tc.require: issueI5X13X
77 */
78 HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_002, TestSize.Level0)
79 {
80 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_002 function start!");
81 uint32_t chargeStateValue = static_cast<uint32_t>(BatteryChargeState::CHARGE_STATE_NONE);
82 int32_t errCode = g_proxy->GetChargingStatus(chargeStateValue);
83 EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
84 BatteryChargeState chargeState = static_cast<BatteryChargeState>(chargeStateValue);
85 EXPECT_TRUE(chargeState >= BatteryChargeState::CHARGE_STATE_NONE &&
86 chargeState <= BatteryChargeState::CHARGE_STATE_BUTT); // the enum value range of BatteryChargeState
87 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_002 function end!");
88 }
89
90 /**
91 * @tc.name: BatteryProxyMockTest_003
92 * @tc.desc: test BatterySrvProxy::GetHealthStatus() when an exception is raised
93 * @tc.type: FUNC
94 * @tc.require: issueI5X13X
95 */
96 HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_003, TestSize.Level0)
97 {
98 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_003 function start!");
99 uint32_t healthStateValue = static_cast<uint32_t>(BatteryHealthState::HEALTH_STATE_UNKNOWN);
100 int32_t errCode = g_proxy->GetHealthStatus(healthStateValue);
101 EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
102 BatteryHealthState healthState = static_cast<BatteryHealthState>(healthStateValue);
103 EXPECT_TRUE(healthState >= BatteryHealthState::HEALTH_STATE_UNKNOWN &&
104 healthState <= BatteryHealthState::HEALTH_STATE_BUTT); // the enum value range of BatteryHealthState
105 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_003 function end!");
106 }
107
108 /**
109 * @tc.name: BatteryProxyMockTest_004
110 * @tc.desc: test BatterySrvProxy::GetPluggedType() when an exception is raised
111 * @tc.type: FUNC
112 * @tc.require: issueI5X13X
113 */
114 HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_004, TestSize.Level0)
115 {
116 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_004 function start!");
117 uint32_t pluggedTypeValue = static_cast<uint32_t>(BatteryPluggedType::PLUGGED_TYPE_NONE);
118 int32_t errCode = g_proxy->GetPluggedType(pluggedTypeValue);
119 EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
120 BatteryPluggedType pluggedType = static_cast<BatteryPluggedType>(pluggedTypeValue);
121 EXPECT_TRUE(pluggedType >= BatteryPluggedType::PLUGGED_TYPE_NONE &&
122 pluggedType <= BatteryPluggedType::PLUGGED_TYPE_BUTT); // the enum value range of BatteryPluggedType
123 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_004 function end!");
124 }
125
126 /**
127 * @tc.name: BatteryProxyMockTest_005
128 * @tc.desc: test BatterySrvProxy::GetPresent() when an exception is raised
129 * @tc.type: FUNC
130 * @tc.require: issueI5X13X
131 */
132 HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_005, TestSize.Level0)
133 {
134 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_005 function start!");
135 bool isPresent = INVALID_BATT_BOOL_VALUE;
136 int32_t errCode = g_proxy->GetPresent(isPresent);
137 EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
138 EXPECT_TRUE(isPresent == INVALID_BATT_BOOL_VALUE);
139 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_005 function end!");
140 }
141
142 /**
143 * @tc.name: BatteryProxyMockTest_006
144 * @tc.desc: test BatterySrvProxy::GetTchnology() when an exception is raised
145 * @tc.type: FUNC
146 * @tc.require: issueI5X13X
147 */
148 HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_006, TestSize.Level0)
149 {
150 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_006 function start!");
151 std::string technology = INVALID_STRING_VALUE;
152 int32_t errCode = g_proxy->GetTechnology(technology);
153 EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
154 EXPECT_TRUE(technology == INVALID_STRING_VALUE);
155 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_006 function end!");
156 }
157
158 /**
159 * @tc.name: BatteryProxyMockTest_007
160 * @tc.desc: test BatterySrvProxy::GetTotalEnergy() when an exception is raised
161 * @tc.type: FUNC
162 * @tc.require: issueI5X13X
163 */
164 HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_007, TestSize.Level0)
165 {
166 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_007 function start!");
167 int32_t totalEnergy = INVALID_BATT_INT_VALUE;
168 int32_t errCode = g_proxy->GetTotalEnergy(totalEnergy);
169 EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
170 EXPECT_TRUE(totalEnergy == INVALID_BATT_INT_VALUE);
171 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_007 function end!");
172 }
173
174 /**
175 * @tc.name: BatteryProxyMockTest_008
176 * @tc.desc: test BatterySrvProxy::GetCurrentAverage() when an exception is raised
177 * @tc.type: FUNC
178 * @tc.require: issueI5X13X
179 */
180 HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_008, TestSize.Level0)
181 {
182 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_008 function start!");
183 int32_t currentAverage = INVALID_BATT_INT_VALUE;
184 int32_t errCode = g_proxy->GetCurrentAverage(currentAverage);
185 EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
186 EXPECT_TRUE(currentAverage == INVALID_BATT_INT_VALUE);
187 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_008 function end!");
188 }
189
190 /**
191 * @tc.name: BatteryProxyMockTest_009
192 * @tc.desc: test BatterySrvProxy::GetNowCurrent() when an exception is raised
193 * @tc.type: FUNC
194 * @tc.require: issueI5X13X
195 */
196 HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_009, TestSize.Level0)
197 {
198 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_009 function start!");
199 int32_t nowCurrent = INVALID_BATT_INT_VALUE;
200 int32_t errCode = g_proxy->GetNowCurrent(nowCurrent);
201 EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
202 EXPECT_TRUE(nowCurrent == INVALID_BATT_INT_VALUE);
203 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_009 function end!");
204 }
205
206 /**
207 * @tc.name: BatteryProxyMockTest_010
208 * @tc.desc: test BatterySrvProxy::GetRemainEnergy() when an exception is raised
209 * @tc.type: FUNC
210 * @tc.require: issueI5X13X
211 */
212 HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_010, TestSize.Level0)
213 {
214 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_010 function start!");
215 int32_t remainEnergy = INVALID_BATT_INT_VALUE;
216 int32_t errCode = g_proxy->GetRemainEnergy(remainEnergy);
217 EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
218 EXPECT_TRUE(remainEnergy == INVALID_BATT_INT_VALUE);
219 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_010 function end!");
220 }
221
222 /**
223 * @tc.name: BatteryProxyMockTest_011
224 * @tc.desc: test BatterySrvProxy::GetBatteryTemperature() when an exception is raised
225 * @tc.type: FUNC
226 * @tc.require: issueI5X13X
227 */
228 HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_011, TestSize.Level0)
229 {
230 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_011 function start!");
231 int32_t temperature = INVALID_BATT_TEMP_VALUE;
232 int32_t errCode = g_proxy->GetBatteryTemperature(temperature);
233 EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
234 EXPECT_TRUE(temperature == INVALID_BATT_TEMP_VALUE);
235 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_011 function end!");
236 }
237
238 /**
239 * @tc.name: BatteryProxyMockTest_012
240 * @tc.desc: test BatterySrvProxy::GetCapacityLevel() when an exception is raised
241 * @tc.type: FUNC
242 * @tc.require: issueI5X13X
243 */
244 HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_012, TestSize.Level0)
245 {
246 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_012 function start!");
247 uint32_t batteryLevelValue = 0;
248 int32_t errCode = g_proxy->GetCapacityLevel(batteryLevelValue);
249 EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
250 BatteryCapacityLevel batteryLevel = static_cast<BatteryCapacityLevel>(batteryLevelValue);
251 EXPECT_TRUE(batteryLevel >= BatteryCapacityLevel::LEVEL_NONE &&
252 batteryLevel <= BatteryCapacityLevel::LEVEL_RESERVED); // the enum value range of BatteryCapacityLevel
253 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_012 function end!");
254 }
255
256 /**
257 * @tc.name: BatteryProxyMockTest_013
258 * @tc.desc: test BatterySrvProxy::GetRemainingChargeTime() when an exception is raised
259 * @tc.type: FUNC
260 * @tc.require: issueI5X13X
261 */
262 HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_013, TestSize.Level0)
263 {
264 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_013 function start!");
265 int64_t remainChargeTime = INVALID_REMAINING_CHARGE_TIME_VALUE;
266 int32_t errCode = g_proxy->GetRemainingChargeTime(remainChargeTime);
267 EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
268 EXPECT_TRUE(remainChargeTime == INVALID_REMAINING_CHARGE_TIME_VALUE);
269 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_013 function end!");
270 }
271
272 /**
273 * @tc.name: BatteryProxyMockTest_014
274 * @tc.desc: test BatterySrvProxy::GetVoltage() when an exception is raised
275 * @tc.type: FUNC
276 * @tc.require: issueI5X13X
277 */
278 HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_014, TestSize.Level0)
279 {
280 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_014 function start!");
281 int32_t voltage = INVALID_BATT_INT_VALUE;
282 int32_t errCode = g_proxy->GetVoltage(voltage);
283 EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
284 EXPECT_TRUE(voltage == INVALID_BATT_INT_VALUE);
285 BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_014 function end!");
286 }
287 } // namespace
288