1 /*
2 * Copyright (c) 2021-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 "battery_sttest.h"
17
18 #include <csignal>
19 #include <iostream>
20 #include <fstream>
21 #include <memory>
22 #include <mutex>
23 #include <streambuf>
24 #include <cstring>
25 #include <thread>
26 #include <vector>
27 #include <sys/stat.h>
28 #include <fcntl.h>
29 #include <sys/types.h>
30 #include <dirent.h>
31
32 #include "battery_log.h"
33 #include "battery_srv_client.h"
34
35 using namespace testing::ext;
36 using namespace OHOS;
37 using namespace OHOS::PowerMgr;
38 using namespace std;
39
40 namespace {
41 const std::string MOCK_BATTERY_PATH = "/data/service/el0/battery/";
42 bool g_isMock = false;
43 }
44
SetUpTestCase(void)45 void BatterySttest::SetUpTestCase(void)
46 {
47 g_isMock = TestUtils::IsMock();
48 GTEST_LOG_(INFO) << " g_isMock: " << g_isMock;
49 }
50
TearDownTestCase(void)51 void BatterySttest::TearDownTestCase(void)
52 {
53 g_isMock = false;
54 TestUtils::ResetOnline();
55 }
56
57 namespace {
58 /**
59 * @tc.name: BatteryST001
60 * @tc.desc: Test IBatterySrv interface GetCapacity
61 * @tc.type: FUNC
62 * @tc.require: issueI6KRS8
63 */
64 HWTEST_F (BatterySttest, BatteryST001, TestSize.Level1)
65 {
66 BATTERY_HILOGI(LABEL_TEST, "BatteryST001 function start!");
67 auto& BatterySrvClient = BatterySrvClient::GetInstance();
68 if (g_isMock) {
69 BATTERY_HILOGI(LABEL_TEST, "BatteryST001 g_isMock 1.");
70 auto tempCapacity = BatterySrvClient.GetCapacity();
71 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "44");
72 auto capacity = BatterySrvClient.GetCapacity();
73 BATTERY_HILOGI(LABEL_TEST, "BatteryST001::capacity=%{public}d.", capacity);
74 GTEST_LOG_(INFO) << "BatteryST001 executing, capacity=" << capacity;
75 EXPECT_TRUE(capacity == 44);
76
77 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", std::to_string(tempCapacity));
78 GTEST_LOG_(INFO) << "BatteryST001 executing, capacity=" << tempCapacity;
79 } else {
80 auto capacity = BatterySrvClient.GetCapacity();
81 BATTERY_HILOGI(LABEL_TEST, "BatteryST001::capacity=%{public}d", capacity);
82 GTEST_LOG_(INFO) << "BatteryST001 executing, capacity=" << capacity;
83 EXPECT_TRUE(capacity <= 100 && capacity >= 0);
84 }
85 BATTERY_HILOGI(LABEL_TEST, "BatteryST001 function end!");
86 }
87
88 /**
89 * @tc.name: BatteryST002
90 * @tc.desc: Test IBatterySrv interface GetChargingStatus when chargestate value is none
91 * @tc.type: FUNC
92 * @tc.require: issueI6KRS8
93 */
94 HWTEST_F (BatterySttest, BatteryST002, TestSize.Level1)
95 {
96 BATTERY_HILOGI(LABEL_TEST, "BatteryST002 function start!");
97 auto& BatterySrvClient = BatterySrvClient::GetInstance();
98 if (g_isMock) {
99 BATTERY_HILOGI(LABEL_TEST, "BatteryST002 g_isMock 1.");
100 auto tempChargeState = BatterySrvClient.GetChargingStatus();
101 std::string chargeStateArr[] = {"Discharging", "Charging", "Not charging", "Full", "Unknown"};
102
103 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status", "Discharging");
104 auto chargeState = BatterySrvClient.GetChargingStatus();
105 BATTERY_HILOGI(LABEL_TEST, "BatteryST002::capacity=%{public}d.", chargeState);
106 GTEST_LOG_(INFO) << "BatteryST002 executing, chargeState=" << static_cast<int32_t>(chargeState);
107
108 EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_NONE);
109 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status",
110 chargeStateArr[static_cast<int32_t>(tempChargeState)]);
111 GTEST_LOG_(INFO) << "BatteryST002 executing, chargeState=" << static_cast<int32_t>(tempChargeState);
112 } else {
113 auto chargeState = BatterySrvClient.GetChargingStatus();
114 BATTERY_HILOGI(LABEL_TEST, "BatteryST002::chargeState=%{public}d",
115 static_cast<int32_t>(chargeState));
116 GTEST_LOG_(INFO) << "BatteryST002 executing, chargeState="
117 << static_cast<int32_t>(chargeState);
118 EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_ENABLE ||
119 chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_FULL);
120 }
121 BATTERY_HILOGI(LABEL_TEST, "BatteryST002 function end!");
122 }
123
124 /**
125 * @tc.name: BatteryST003
126 * @tc.desc: Test IBatterySrv interface GetChargingStatus when chargestate value is enable
127 * @tc.type: FUNC
128 * @tc.require: issueI6KRS8
129 */
130 HWTEST_F (BatterySttest, BatteryST003, TestSize.Level1)
131 {
132 BATTERY_HILOGI(LABEL_TEST, "BatteryST003 function start!");
133 auto& BatterySrvClient = BatterySrvClient::GetInstance();
134 if (g_isMock) {
135 BATTERY_HILOGI(LABEL_TEST, "BatteryST003 g_isMock 1.");
136 auto tempChargeState = BatterySrvClient.GetChargingStatus();
137 std::string chargeStateArr[] = {"Discharging", "Charging", "Not charging", "Full", "Unknown"};
138
139 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status", "Charging");
140 auto chargeState = BatterySrvClient.GetChargingStatus();
141 GTEST_LOG_(INFO) << "BatteryST003 executing, chargeState=" << static_cast<int32_t>(chargeState);
142
143 EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_ENABLE);
144 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status",
145 chargeStateArr[static_cast<int32_t>(tempChargeState)]);
146 GTEST_LOG_(INFO) << "BatteryST003 executing, chargeState=" << static_cast<int32_t>(tempChargeState);
147 } else {
148 auto chargeState = BatterySrvClient.GetChargingStatus();
149 BATTERY_HILOGI(LABEL_TEST, "BatteryST003::chargeState=%{public}d",
150 static_cast<int32_t>(chargeState));
151 GTEST_LOG_(INFO) << "BatteryST003 executing, chargeState="
152 << static_cast<int32_t>(chargeState);
153 EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_ENABLE ||
154 chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_FULL);
155 }
156 BATTERY_HILOGI(LABEL_TEST, "BatteryST003 function end!");
157 }
158
159 /**
160 * @tc.name: BatteryST004
161 * @tc.desc: Test IBatterySrv interface GetChargingStatus when chargestate value is full
162 * @tc.type: FUNC
163 * @tc.require: issueI6KRS8
164 */
165 HWTEST_F (BatterySttest, BatteryST004, TestSize.Level1)
166 {
167 BATTERY_HILOGI(LABEL_TEST, "BatteryST004 function start!");
168 auto& BatterySrvClient = BatterySrvClient::GetInstance();
169 if (g_isMock) {
170 BATTERY_HILOGI(LABEL_TEST, "BatteryST004 g_isMock 1.");
171 auto tempChargeState = BatterySrvClient.GetChargingStatus();
172 std::string chargeStateArr[] = {"Discharging", "Charging", "Not charging", "Full", "Unknown"};
173
174 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status", "Full");
175 auto chargeState = BatterySrvClient.GetChargingStatus();
176 GTEST_LOG_(INFO) << "BatteryST004 executing, chargeState=" << static_cast<int32_t>(chargeState);
177
178 EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_FULL);
179 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status",
180 chargeStateArr[static_cast<int32_t>(tempChargeState)]);
181 GTEST_LOG_(INFO) << "BatteryST004 executing, chargeState=" << static_cast<int32_t>(tempChargeState);
182 } else {
183 auto chargeState = BatterySrvClient.GetChargingStatus();
184 BATTERY_HILOGI(LABEL_TEST, "BatteryST004::chargeState=%{public}d",
185 static_cast<int32_t>(chargeState));
186 GTEST_LOG_(INFO) << "BatteryST004 executing, chargeState="
187 << static_cast<int32_t>(chargeState);
188 EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_ENABLE ||
189 chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_FULL);
190 }
191 BATTERY_HILOGI(LABEL_TEST, "BatteryST004 function end!");
192 }
193
194 /**
195 * @tc.name: BatteryST005
196 * @tc.desc: Test IBatterySrv interface GetChargingStatus when chargestate value is disable
197 * @tc.type: FUNC
198 * @tc.require: issueI6KRS8
199 */
200 HWTEST_F (BatterySttest, BatteryST005, TestSize.Level1)
201 {
202 BATTERY_HILOGI(LABEL_TEST, "BatteryST005 function start!");
203 auto& BatterySrvClient = BatterySrvClient::GetInstance();
204 if (g_isMock) {
205 BATTERY_HILOGI(LABEL_TEST, "BatteryST005 g_isMock 1.");
206 auto tempChargeState = BatterySrvClient.GetChargingStatus();
207 std::string chargeStateArr[] = {"Discharging", "Charging", "Not charging", "Full", "Unknown"};
208
209 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status", "Not charging");
210 auto chargeState = BatterySrvClient.GetChargingStatus();
211 GTEST_LOG_(INFO) << "BatteryST005 executing, chargeState=" << static_cast<int32_t>(chargeState);
212
213 EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_DISABLE);
214 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status",
215 chargeStateArr[static_cast<int32_t>(tempChargeState)]);
216 GTEST_LOG_(INFO) << "BatteryST005 executing, chargeState=" << static_cast<int32_t>(tempChargeState);
217 } else {
218 auto chargeState = BatterySrvClient.GetChargingStatus();
219 BATTERY_HILOGI(LABEL_TEST, "BatteryST005::chargeState=%{public}d",
220 static_cast<int32_t>(chargeState));
221 GTEST_LOG_(INFO) << "BatteryST005 executing, chargeState="
222 << static_cast<int32_t>(chargeState);
223 EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_ENABLE ||
224 chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_FULL);
225 }
226 BATTERY_HILOGI(LABEL_TEST, "BatteryST005 function end!");
227 }
228
229 /**
230 * @tc.name: BatteryST006
231 * @tc.desc: Test IBatterySrv interface GetChargingStatus when chargestate value is butt
232 * @tc.type: FUNC
233 * @tc.require: issueI6KRS8
234 */
235 HWTEST_F (BatterySttest, BatteryST006, TestSize.Level1)
236 {
237 BATTERY_HILOGI(LABEL_TEST, "BatteryST006 function start!");
238 auto& BatterySrvClient = BatterySrvClient::GetInstance();
239 if (g_isMock) {
240 BATTERY_HILOGI(LABEL_TEST, "BatteryST006 g_isMock 1.");
241 auto tempChargeState = BatterySrvClient.GetChargingStatus();
242 std::string chargeStateArr[] = {"Discharging", "Charging", "Not charging", "Full", "Unknown"};
243
244 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status", "Unknown");
245 auto chargeState = BatterySrvClient.GetChargingStatus();
246 GTEST_LOG_(INFO) << "BatteryST006 executing, chargeState=" << static_cast<int32_t>(chargeState);
247
248 EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_BUTT);
249 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status",
250 chargeStateArr[static_cast<int32_t>(tempChargeState)]);
251 GTEST_LOG_(INFO) << "BatteryST006 executing, chargeState=" << static_cast<int32_t>(tempChargeState);
252 } else {
253 auto chargeState = BatterySrvClient.GetChargingStatus();
254 BATTERY_HILOGI(LABEL_TEST, "BatteryST006::chargeState=%{public}d",
255 static_cast<int32_t>(chargeState));
256 GTEST_LOG_(INFO) << "BatteryST006 executing, chargeState="
257 << static_cast<int32_t>(chargeState);
258 EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_ENABLE ||
259 chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_FULL);
260 }
261 BATTERY_HILOGI(LABEL_TEST, "BatteryST006 function end!");
262 }
263
264 /**
265 * @tc.name: BatteryST007
266 * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_GOOD
267 * @tc.type: FUNC
268 * @tc.require: issueI6KRS8
269 */
270 HWTEST_F (BatterySttest, BatteryST007, TestSize.Level1)
271 {
272 BATTERY_HILOGI(LABEL_TEST, "BatteryST007 function start!");
273 auto& BatterySrvClient = BatterySrvClient::GetInstance();
274 if (g_isMock) {
275 BATTERY_HILOGI(LABEL_TEST, "BatteryST007 g_isMock 1.");
276 auto tempHealthState = BatterySrvClient.GetHealthStatus();
277 std::string healthStateArr[] = {"Unknown", "Good", "Hot", "Over voltage", "Cold", "Dead"};
278
279 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health", "Good");
280 auto healthState = BatterySrvClient.GetHealthStatus();
281 GTEST_LOG_(INFO) << "BatteryST007 executing, healthState=" << static_cast<int32_t>(healthState);
282
283 EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
284 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health",
285 healthStateArr[static_cast<int32_t>(tempHealthState)]);
286 GTEST_LOG_(INFO) << "BatteryST007 executing, healthState=" << static_cast<int32_t>(tempHealthState);
287 } else {
288 auto healthState = BatterySrvClient.GetHealthStatus();
289 BATTERY_HILOGI(LABEL_TEST, "BatteryST007::healthState=%{public}d",
290 static_cast<int32_t>(healthState));
291 GTEST_LOG_(INFO) << "BatteryST007 executing, healthState="
292 << static_cast<int32_t>(healthState);
293 EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
294 }
295 BATTERY_HILOGI(LABEL_TEST, "BatteryST007 function end!");
296 }
297
298 /**
299 * @tc.name: BatteryST008
300 * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_COLD
301 * @tc.type: FUNC
302 * @tc.require: issueI6KRS8
303 */
304 HWTEST_F (BatterySttest, BatteryST008, TestSize.Level1)
305 {
306 BATTERY_HILOGI(LABEL_TEST, "BatteryST008 function start!");
307 auto& BatterySrvClient = BatterySrvClient::GetInstance();
308 if (g_isMock) {
309 BATTERY_HILOGI(LABEL_TEST, "BatteryST008 g_isMock 1.");
310 auto tempHealthState = BatterySrvClient.GetHealthStatus();
311 std::string healthStateArr[] = {"Unknown", "Good", "Hot", "Over voltage", "Cold", "Dead"};
312
313 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health", "Cold");
314 auto healthState = BatterySrvClient.GetHealthStatus();
315 GTEST_LOG_(INFO) << "BatteryST008 executing, healthState=" << static_cast<int32_t>(healthState);
316
317 EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_COLD);
318 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health",
319 healthStateArr[static_cast<int32_t>(tempHealthState)]);
320 GTEST_LOG_(INFO) << "BatteryST008 executing, healthState=" << static_cast<int32_t>(tempHealthState);
321 } else {
322 auto healthState = BatterySrvClient.GetHealthStatus();
323 BATTERY_HILOGI(LABEL_TEST, "BatteryST008::healthState=%{public}d",
324 static_cast<int32_t>(healthState));
325 GTEST_LOG_(INFO) << "BatteryST008 executing, healthState="
326 << static_cast<int32_t>(healthState);
327 EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
328 }
329 BATTERY_HILOGI(LABEL_TEST, "BatteryST008 function end!");
330 }
331
332 /**
333 * @tc.name: BatteryST009
334 * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_OVERHEAT
335 * @tc.type: FUNC
336 * @tc.require: issueI6KRS8
337 */
338 HWTEST_F (BatterySttest, BatteryST009, TestSize.Level1)
339 {
340 BATTERY_HILOGI(LABEL_TEST, "BatteryST009 function start!");
341 auto& BatterySrvClient = BatterySrvClient::GetInstance();
342 if (g_isMock) {
343 BATTERY_HILOGI(LABEL_TEST, "BatteryST009 g_isMock 1.");
344 auto tempHealthState = BatterySrvClient.GetHealthStatus();
345 std::string healthStateArr[] = {"Unknown", "Good", "Hot", "Over voltage", "Cold", "Dead"};
346
347 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health", "Hot");
348 auto healthState = BatterySrvClient.GetHealthStatus();
349 GTEST_LOG_(INFO) << "BatteryST009 executing, healthState=" << static_cast<int32_t>(healthState);
350
351 EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_OVERHEAT);
352 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health",
353 healthStateArr[static_cast<int32_t>(tempHealthState)]);
354 GTEST_LOG_(INFO) << "BatteryST009 executing, healthState=" << static_cast<int32_t>(tempHealthState);
355 } else {
356 auto healthState = BatterySrvClient.GetHealthStatus();
357 BATTERY_HILOGI(LABEL_TEST, "BatteryST009::healthState=%{public}d",
358 static_cast<int32_t>(healthState));
359 GTEST_LOG_(INFO) << "BatteryST009 executing, healthState="
360 << static_cast<int32_t>(healthState);
361 EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
362 }
363 BATTERY_HILOGI(LABEL_TEST, "BatteryST009 function end!");
364 }
365
366 /**
367 * @tc.name: BatteryST010
368 * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_OVERVOLTAGE
369 * @tc.type: FUNC
370 * @tc.require: issueI6KRS8
371 */
372 HWTEST_F (BatterySttest, BatteryST010, TestSize.Level1)
373 {
374 BATTERY_HILOGI(LABEL_TEST, "BatteryST010 function start!");
375 auto& BatterySrvClient = BatterySrvClient::GetInstance();
376 if (g_isMock) {
377 BATTERY_HILOGI(LABEL_TEST, "BatteryST010 g_isMock 1.");
378 auto tempHealthState = BatterySrvClient.GetHealthStatus();
379 std::string healthStateArr[] = {"Unknown", "Good", "Hot", "Over voltage", "Cold", "Dead"};
380
381 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health", "Over voltage");
382 auto healthState = BatterySrvClient.GetHealthStatus();
383 GTEST_LOG_(INFO) << "BatteryST010 executing, healthState=" << static_cast<int32_t>(healthState);
384
385 EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_OVERVOLTAGE);
386 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health",
387 healthStateArr[static_cast<int32_t>(tempHealthState)]);
388 GTEST_LOG_(INFO) << "BatteryST010 executing, healthState=" << static_cast<int32_t>(tempHealthState);
389 } else {
390 auto healthState = BatterySrvClient.GetHealthStatus();
391 BATTERY_HILOGI(LABEL_TEST, "BatteryST010::healthState=%{public}d",
392 static_cast<int32_t>(healthState));
393 GTEST_LOG_(INFO) << "BatteryST010 executing, healthState="
394 << static_cast<int32_t>(healthState);
395 EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
396 }
397 BATTERY_HILOGI(LABEL_TEST, "BatteryST010 function end!");
398 }
399
400 /**
401 * @tc.name: BatteryST011
402 * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_DEAD
403 * @tc.type: FUNC
404 * @tc.require: issueI6KRS8
405 */
406 HWTEST_F (BatterySttest, BatteryST011, TestSize.Level1)
407 {
408 BATTERY_HILOGI(LABEL_TEST, "BatteryST011 function start!");
409 auto& BatterySrvClient = BatterySrvClient::GetInstance();
410 if (g_isMock) {
411 BATTERY_HILOGI(LABEL_TEST, "BatteryST011 g_isMock 1.");
412 auto tempHealthState = BatterySrvClient.GetHealthStatus();
413 std::string healthStateArr[] = {"Unknown", "Good", "Hot", "Over voltage", "Cold", "Dead"};
414
415 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health", "Dead");
416 auto healthState = BatterySrvClient.GetHealthStatus();
417 GTEST_LOG_(INFO) << "BatteryST011 executing, healthState=" << static_cast<int32_t>(healthState);
418
419 EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_DEAD);
420 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health",
421 healthStateArr[static_cast<int32_t>(tempHealthState)]);
422 GTEST_LOG_(INFO) << "BatteryST011 executing, healthState=" << static_cast<int32_t>(tempHealthState);
423 } else {
424 auto healthState = BatterySrvClient.GetHealthStatus();
425 BATTERY_HILOGI(LABEL_TEST, "BatteryST011::healthState=%{public}d",
426 static_cast<int32_t>(healthState));
427 GTEST_LOG_(INFO) << "BatteryST011 executing, healthState="
428 << static_cast<int32_t>(healthState);
429 EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
430 }
431 BATTERY_HILOGI(LABEL_TEST, "BatteryST011 function end!");
432 }
433
434 /**
435 * @tc.name: BatteryST012
436 * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_UNKNOWN
437 * @tc.type: FUNC
438 * @tc.require: issueI6KRS8
439 */
440 HWTEST_F (BatterySttest, BatteryST012, TestSize.Level1)
441 {
442 BATTERY_HILOGI(LABEL_TEST, "BatteryST012 function start!");
443 auto& BatterySrvClient = BatterySrvClient::GetInstance();
444 if (g_isMock) {
445 BATTERY_HILOGI(LABEL_TEST, "BatteryST012 g_isMock 1.");
446 auto tempHealthState = BatterySrvClient.GetHealthStatus();
447 std::string healthStateArr[] = {"Unknown", "Good", "Hot", "Over voltage", "Cold", "Dead"};
448
449 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health", "Unknown");
450 auto healthState = BatterySrvClient.GetHealthStatus();
451 GTEST_LOG_(INFO) << "BatteryST012 executing, healthState=" << static_cast<int32_t>(healthState);
452
453 EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_UNKNOWN);
454 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health",
455 healthStateArr[static_cast<int32_t>(tempHealthState)]);
456 GTEST_LOG_(INFO) << "BatteryST012 executing, healthState=" << static_cast<int32_t>(tempHealthState);
457 } else {
458 auto healthState = BatterySrvClient.GetHealthStatus();
459 BATTERY_HILOGI(LABEL_TEST, "BatteryST012::healthState=%{public}d",
460 static_cast<int32_t>(healthState));
461 GTEST_LOG_(INFO) << "BatteryST012 executing, healthState="
462 << static_cast<int32_t>(healthState);
463 EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
464 }
465 BATTERY_HILOGI(LABEL_TEST, "BatteryST012 function end!");
466 }
467
468 /**
469 * @tc.name: BatteryST013
470 * @tc.desc: Test IBatterySrv interface GetPresent when present is true
471 * @tc.type: FUNC
472 * @tc.require: issueI6KRS8
473 */
474 HWTEST_F (BatterySttest, BatteryST013, TestSize.Level1)
475 {
476 BATTERY_HILOGI(LABEL_TEST, "BatteryST013 function start!");
477 auto& BatterySrvClient = BatterySrvClient::GetInstance();
478 if (g_isMock) {
479 BATTERY_HILOGI(LABEL_TEST, "BatteryST012 g_isMock 1.");
480 auto tempPresent = BatterySrvClient.GetPresent();
481
482 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", "1");
483 auto present = BatterySrvClient.GetPresent();
484 GTEST_LOG_(INFO) << "BatteryST013 executing, present=" << present;
485
486 EXPECT_TRUE(present);
487 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", std::to_string(tempPresent));
488 GTEST_LOG_(INFO) << "BatteryST013 executing, tempPresent=" << static_cast<int32_t>(tempPresent);
489 } else {
490 auto present = BatterySrvClient.GetPresent();
491 BATTERY_HILOGI(LABEL_TEST, "BatteryST013::present=%{public}d", present);
492 GTEST_LOG_(INFO) << "BatteryST013 executing, present=" << present;
493 EXPECT_TRUE(present);
494 }
495 BATTERY_HILOGI(LABEL_TEST, "BatteryST013 function end!");
496 }
497
498 /**
499 * @tc.name: BatteryST014
500 * @tc.desc: Test IBatterySrv interface GetPresent when present is false
501 * @tc.type: FUNC
502 * @tc.require: issueI6KRS8
503 */
504 HWTEST_F (BatterySttest, BatteryST014, TestSize.Level1)
505 {
506 BATTERY_HILOGI(LABEL_TEST, "BatteryST014 function start!");
507 auto& BatterySrvClient = BatterySrvClient::GetInstance();
508 if (g_isMock) {
509 BATTERY_HILOGI(LABEL_TEST, "BatteryST014 g_isMock 1.");
510 auto tempPresent = BatterySrvClient.GetPresent();
511
512 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", "0");
513 auto present = BatterySrvClient.GetPresent();
514 GTEST_LOG_(INFO) << "BatteryST014 executing, present=" << present;
515
516 EXPECT_FALSE(present);
517 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", std::to_string(tempPresent));
518 GTEST_LOG_(INFO) << "BatteryST014 executing, tempPresent=" << static_cast<int32_t>(tempPresent);
519 } else {
520 auto present = BatterySrvClient.GetPresent();
521 BATTERY_HILOGI(LABEL_TEST, "BatteryST014::present=%{public}d", present);
522 GTEST_LOG_(INFO) << "BatteryST014 executing, present=" << present;
523 EXPECT_TRUE(present);
524 }
525 BATTERY_HILOGI(LABEL_TEST, "BatteryST014 function end!");
526 }
527
528 /**
529 * @tc.name: BatteryST015
530 * @tc.desc: Test IBatterySrv interface GetVoltage
531 * @tc.type: FUNC
532 * @tc.require: issueI6KRS8
533 */
534 HWTEST_F (BatterySttest, BatteryST015, TestSize.Level1)
535 {
536 BATTERY_HILOGI(LABEL_TEST, "BatteryST015 function start!");
537 auto& BatterySrvClient = BatterySrvClient::GetInstance();
538 if (g_isMock) {
539 BATTERY_HILOGI(LABEL_TEST, "BatteryST015 g_isMock 1.");
540 auto tempVoltagenow = BatterySrvClient.GetVoltage();
541
542 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", "4654321");
543 auto voltage = BatterySrvClient.GetVoltage();
544 GTEST_LOG_(INFO) << "BatteryST015 executing, voltage=" << voltage;
545
546 EXPECT_TRUE(voltage == 4654321);
547 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", std::to_string(tempVoltagenow));
548 GTEST_LOG_(INFO) << "BatteryST015 executing, tempPresent=" << static_cast<int32_t>(tempVoltagenow);
549 } else {
550 auto voltage = BatterySrvClient.GetVoltage();
551 BATTERY_HILOGI(LABEL_TEST, "BatteryST015::voltage=%{public}d", voltage);
552 GTEST_LOG_(INFO) << "BatteryST015 executing, voltage=" << voltage;
553 EXPECT_TRUE(voltage >= 0);
554 }
555 BATTERY_HILOGI(LABEL_TEST, "BatteryST015 function end!");
556 }
557
558 /**
559 * @tc.name: BatteryST016
560 * @tc.desc: Test IBatterySrv interface GetTemperature
561 * @tc.type: FUNC
562 * @tc.require: issueI6KRS8
563 */
564 HWTEST_F (BatterySttest, BatteryST016, TestSize.Level1)
565 {
566 BATTERY_HILOGI(LABEL_TEST, "BatteryST016 function start!");
567 auto& BatterySrvClient = BatterySrvClient::GetInstance();
568 if (g_isMock) {
569 BATTERY_HILOGI(LABEL_TEST, "BatteryST016 g_isMock 1.");
570 auto tempTempPresent = BatterySrvClient.GetBatteryTemperature();
571
572 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", "234");
573 auto temperature = BatterySrvClient.GetBatteryTemperature();
574 GTEST_LOG_(INFO) << "BatteryST016 executing, temperature=" << temperature;
575
576 EXPECT_TRUE(temperature == 234);
577 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", std::to_string(tempTempPresent));
578 GTEST_LOG_(INFO) << "BatteryST016 executing, temperature=" << static_cast<int32_t>(tempTempPresent);
579 } else {
580 auto temperature = BatterySrvClient.GetBatteryTemperature();
581 BATTERY_HILOGI(LABEL_TEST, "BatteryST016::temperature=%{public}d", temperature);
582 GTEST_LOG_(INFO) << "BatteryST016 executing, temperature=" << temperature;
583 EXPECT_TRUE(temperature >= 0 && temperature <= 600);
584 }
585 BATTERY_HILOGI(LABEL_TEST, "BatteryST016 function end!");
586 }
587
588 /**
589 * @tc.name: BatteryST017
590 * @tc.desc: Test IBatterySrv interface GetTechnology
591 * @tc.type: FUNC
592 * @tc.require: issueI6KRS8
593 */
594 HWTEST_F (BatterySttest, BatteryST017, TestSize.Level1)
595 {
596 BATTERY_HILOGI(LABEL_TEST, "BatteryST017 function start!");
597 auto& BatterySrvClient = BatterySrvClient::GetInstance();
598 if (g_isMock) {
599 BATTERY_HILOGI(LABEL_TEST, "BatteryST017 g_isMock 1.");
600 std::string tempTechnology = BatterySrvClient.GetTechnology();
601
602 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos-fgu/technology", "H2");
603 auto technology = BatterySrvClient.GetTechnology();
604 GTEST_LOG_(INFO) << "BatteryST017 executing, technology=" << technology;
605
606 EXPECT_TRUE(technology == "H2");
607 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos-fgu/technology", tempTechnology);
608 GTEST_LOG_(INFO) << "BatteryST017 executing, technology=" << tempTechnology;
609 } else {
610 auto technology = BatterySrvClient.GetTechnology();
611 BATTERY_HILOGI(LABEL_TEST, "BatteryST017::technology=%{public}s", technology.c_str());
612 GTEST_LOG_(INFO) << "BatteryST017 executing, technology=" << technology;
613 #ifdef PC_TEST
614 EXPECT_TRUE(technology == "Li-ion");
615 #else
616 EXPECT_TRUE(technology == "Li-poly");
617 #endif
618 }
619 BATTERY_HILOGI(LABEL_TEST, "BatteryST017 function end!");
620 }
621
622 /**
623 * @tc.name: BatteryST018
624 * @tc.desc: Test IBatterySrv interface GetPluggedType when pluggedType value is PLUGGED_TYPE_AC
625 * @tc.type: FUNC
626 * @tc.require: issueI6KRS8
627 */
628 HWTEST_F (BatterySttest, BatteryST018, TestSize.Level1)
629 {
630 BATTERY_HILOGI(LABEL_TEST, "BatteryST018 function start!");
631 auto& BatterySrvClient = BatterySrvClient::GetInstance();
632 if (g_isMock) {
633 BATTERY_HILOGI(LABEL_TEST, "BatteryST018 g_isMock 1.");
634 TestUtils::ResetOnline();
635 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/online", "1");
636 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/type", "Mains");
637
638 auto pluggedType = BatterySrvClient.GetPluggedType();
639 GTEST_LOG_(INFO) << "BatteryST018 executing, pluggedType=" << static_cast<int32_t>(pluggedType);
640
641 EXPECT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_AC);
642 } else {
643 auto pluggedType = BatterySrvClient.GetPluggedType();
644 BATTERY_HILOGI(LABEL_TEST, "BatteryST018::pluggedType=%{public}d",
645 static_cast<int32_t>(pluggedType));
646 GTEST_LOG_(INFO) << "BatteryST018 executing, pluggedType="
647 << static_cast<int32_t>(pluggedType);
648 #ifdef PC_TEST
649 EXPECT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_AC);
650 #else
651 EXPECT_FALSE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_BUTT);
652 #endif
653 }
654 BATTERY_HILOGI(LABEL_TEST, "BatteryST018 function end!");
655 }
656
657 /**
658 * @tc.name: BatteryST019
659 * @tc.desc: Test IBatterySrv interface GetPluggedType when pluggedType value is PLUGGED_TYPE_USB
660 * @tc.type: FUNC
661 * @tc.require: issueI6KRS8
662 */
663 HWTEST_F (BatterySttest, BatteryST019, TestSize.Level1)
664 {
665 BATTERY_HILOGI(LABEL_TEST, "BatteryST019 function start!");
666 auto& BatterySrvClient = BatterySrvClient::GetInstance();
667 if (g_isMock) {
668 BATTERY_HILOGI(LABEL_TEST, "BatteryST019 g_isMock 1.");
669 TestUtils::ResetOnline();
670 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/online", "1");
671 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/type", "USB");
672
673 auto pluggedType = BatterySrvClient.GetPluggedType();
674 GTEST_LOG_(INFO) << "BatteryST019 executing, pluggedType=" << static_cast<int32_t>(pluggedType);
675
676 EXPECT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_USB);
677 } else {
678 auto pluggedType = BatterySrvClient.GetPluggedType();
679 BATTERY_HILOGI(LABEL_TEST, "BatteryST019::pluggedType=%{public}d",
680 static_cast<int32_t>(pluggedType));
681 GTEST_LOG_(INFO) << "BatteryST019 executing, pluggedType="
682 << static_cast<int32_t>(pluggedType);
683 #ifdef PC_TEST
684 EXPECT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_AC);
685 #else
686 EXPECT_FALSE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_BUTT);
687 #endif
688 }
689 BATTERY_HILOGI(LABEL_TEST, "BatteryST019 function end!");
690 }
691
692 /**
693 * @tc.name: BatteryST020
694 * @tc.desc: Test IBatterySrv interface GetPluggedType when pluggedType value is PLUGGED_TYPE_WIRELESS
695 * @tc.type: FUNC
696 * @tc.require: issueI6KRS8
697 */
698 HWTEST_F (BatterySttest, BatteryST020, TestSize.Level1)
699 {
700 BATTERY_HILOGI(LABEL_TEST, "BatteryST020 function start!");
701 auto& BatterySrvClient = BatterySrvClient::GetInstance();
702 if (g_isMock) {
703 BATTERY_HILOGI(LABEL_TEST, "BatteryST020 g_isMock 1.");
704 TestUtils::ResetOnline();
705 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/online", "1");
706 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/type", "Wireless");
707
708 auto pluggedType = BatterySrvClient.GetPluggedType();
709 GTEST_LOG_(INFO) << "BatteryST020 executing, pluggedType=" << static_cast<int32_t>(pluggedType);
710
711 EXPECT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_WIRELESS);
712 } else {
713 auto pluggedType = BatterySrvClient.GetPluggedType();
714 BATTERY_HILOGI(LABEL_TEST, "BatteryST020::pluggedType=%{public}d",
715 static_cast<int32_t>(pluggedType));
716 GTEST_LOG_(INFO) << "BatteryST020 executing, pluggedType="
717 << static_cast<int32_t>(pluggedType);
718 #ifdef PC_TEST
719 EXPECT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_AC);
720 #else
721 EXPECT_FALSE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_BUTT);
722 #endif
723 }
724 BATTERY_HILOGI(LABEL_TEST, "BatteryST020 function end!");
725 }
726
727 /**
728 * @tc.name: BatteryST021
729 * @tc.desc: Test IBatterySrv interface GetPluggedType when pluggedType value is PLUGGED_TYPE_BUTT
730 * ParsePluggedType return HDF_ERR_NOT_SUPPORT, g_service->GetPluggedType FAIL
731 * @tc.type: FUNC
732 * @tc.require: issueI6KRS8
733 */
734 HWTEST_F (BatterySttest, BatteryST021, TestSize.Level1)
735 {
736 BATTERY_HILOGI(LABEL_TEST, "BatteryST021 function start!");
737 auto& BatterySrvClient = BatterySrvClient::GetInstance();
738 if (g_isMock) {
739 BATTERY_HILOGI(LABEL_TEST, "BatteryST021 g_isMock 1.");
740 TestUtils::ResetOnline();
741 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/online", "1");
742 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/type", "Unknown");
743
744 auto pluggedType = BatterySrvClient.GetPluggedType();
745 GTEST_LOG_(INFO) << "BatteryST021 executing, pluggedType=" << static_cast<int32_t>(pluggedType);
746
747 EXPECT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_NONE);
748 } else {
749 auto pluggedType = BatterySrvClient.GetPluggedType();
750 BATTERY_HILOGI(LABEL_TEST, "BatteryST021::pluggedType=%{public}d",
751 static_cast<int32_t>(pluggedType));
752 GTEST_LOG_(INFO) << "BatteryST021 executing, pluggedType="
753 << static_cast<int32_t>(pluggedType);
754 #ifdef PC_TEST
755 EXPECT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_AC);
756 #else
757 EXPECT_FALSE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_BUTT);
758 #endif
759 }
760 BATTERY_HILOGI(LABEL_TEST, "BatteryST021 function end!");
761 }
762 }
763