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 "hdi_service_test.h"
17 #include <chrono>
18 #include <condition_variable>
19 #include <csignal>
20 #include <cstring>
21 #include <dirent.h>
22 #include <fcntl.h>
23 #include <fstream>
24 #include <iostream>
25 #include <memory>
26 #include <mutex>
27 #include <streambuf>
28 #include <sys/stat.h>
29 #include <thread>
30 #include <vector>
31 #include "battery_thread_test.h"
32 #include "battery_vibrate.h"
33 #include "hdf_base.h"
34 #include "power_supply_provider.h"
35 #include "battery_log.h"
36
37 using namespace testing::ext;
38 using namespace OHOS;
39 using namespace OHOS::HDI::Battery;
40 using namespace OHOS::HDI::Battery::V1_1;
41 using namespace std;
42
43 namespace HdiServiceTest {
44 const std::string SYSTEM_BATTERY_PATH = "/sys/class/power_supply";
45 const std::string MOCK_BATTERY_PATH = "/data/service/el0/battery/";
46 static std::vector<std::string> g_filenodeName;
47 static std::map<std::string, std::string> g_nodeInfo;
48 const int STR_TO_LONG_LEN = 10;
49 const int NUM_ZERO = 0;
50 constexpr int32_t ERROR = -1;
51 constexpr int32_t MAX_BUFF_SIZE = 128;
52 constexpr int32_t MAX_SYSFS_SIZE = 64;
53 std::unique_ptr<PowerSupplyProvider> giver_ = nullptr;
54
SetUpTestCase(void)55 void HdiServiceTest::SetUpTestCase(void)
56 {
57 giver_ = std::make_unique<PowerSupplyProvider>();
58 if (giver_ == nullptr) {
59 BATTERY_HILOGI(LABEL_TEST, "Failed to get PowerSupplyProvider");
60 }
61 }
62
TearDownTestCase(void)63 void HdiServiceTest::TearDownTestCase(void)
64 {
65 }
66
SetUp(void)67 void HdiServiceTest::SetUp(void)
68 {
69 }
70
TearDown(void)71 void HdiServiceTest::TearDown(void)
72 {
73 }
74
75 struct StringEnumMap {
76 const char* str;
77 int32_t enumVal;
78 };
79
CreateFile(std::string path,std::string content)80 std::string CreateFile(std::string path, std::string content)
81 {
82 std::ofstream stream(path.c_str());
83 if (!stream.is_open()) {
84 BATTERY_HILOGI(LABEL_TEST, "Cannot create file");
85 return nullptr;
86 }
87 stream << content.c_str() << std::endl;
88 stream.close();
89 return path;
90 }
91
CheckSubfolderNode(const std::string & path)92 static void CheckSubfolderNode(const std::string& path)
93 {
94 DIR *dir = nullptr;
95 struct dirent* entry = nullptr;
96 std::string batteryPath = SYSTEM_BATTERY_PATH + "/" + path;
97
98 dir = opendir(batteryPath.c_str());
99 if (dir == nullptr) {
100 BATTERY_HILOGI(LABEL_TEST, "subfolder file is not exist.");
101 return;
102 }
103
104 while (true) {
105 entry = readdir(dir);
106 if (entry == nullptr) {
107 break;
108 }
109
110 if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
111 continue;
112 }
113
114 if (entry->d_type == DT_DIR || entry->d_type == DT_LNK) {
115 continue;
116 }
117
118 if ((strcmp(entry->d_name, "type") == 0) && (g_nodeInfo["type"] == "") &&
119 (strcasecmp(path.c_str(), "battery") != 0)) {
120 g_nodeInfo["type"] = path;
121 }
122
123 for (auto iter = g_nodeInfo.begin(); iter != g_nodeInfo.end(); ++iter) {
124 if ((strcmp(entry->d_name, iter->first.c_str()) == 0) && (g_nodeInfo[iter->first] == "")) {
125 g_nodeInfo[iter->first] = path;
126 }
127 }
128 }
129 closedir(dir);
130 }
131
TraversalBaseNode()132 static void TraversalBaseNode()
133 {
134 g_nodeInfo.insert(std::make_pair("type", ""));
135 g_nodeInfo.insert(std::make_pair("online", ""));
136 g_nodeInfo.insert(std::make_pair("current_max", ""));
137 g_nodeInfo.insert(std::make_pair("voltage_max", ""));
138 g_nodeInfo.insert(std::make_pair("capacity", ""));
139 g_nodeInfo.insert(std::make_pair("voltage_now", ""));
140 g_nodeInfo.insert(std::make_pair("temp", ""));
141 g_nodeInfo.insert(std::make_pair("health", ""));
142 g_nodeInfo.insert(std::make_pair("status", ""));
143 g_nodeInfo.insert(std::make_pair("present", ""));
144 g_nodeInfo.insert(std::make_pair("charge_counter", ""));
145 g_nodeInfo.insert(std::make_pair("technology", ""));
146 g_nodeInfo.insert(std::make_pair("charge_full", ""));
147 g_nodeInfo.insert(std::make_pair("current_avg", ""));
148 g_nodeInfo.insert(std::make_pair("current_now", ""));
149 g_nodeInfo.insert(std::make_pair("charge_now", ""));
150
151 auto iter = g_filenodeName.begin();
152 while (iter != g_filenodeName.end()) {
153 if (*iter == "battery") {
154 CheckSubfolderNode(*iter);
155 iter = g_filenodeName.erase(iter);
156 } else {
157 iter++;
158 }
159 }
160
161 iter = g_filenodeName.begin();
162 while (iter != g_filenodeName.end()) {
163 if (*iter == "Battery") {
164 CheckSubfolderNode(*iter);
165 iter = g_filenodeName.erase(iter);
166 } else {
167 iter++;
168 }
169 }
170
171 for (auto it = g_filenodeName.begin(); it != g_filenodeName.end(); ++it) {
172 CheckSubfolderNode(*it);
173 }
174 }
175
InitBaseSysfs(void)176 static int32_t InitBaseSysfs(void)
177 {
178 DIR* dir = nullptr;
179 struct dirent* entry = nullptr;
180 int32_t index = 0;
181
182 dir = opendir(SYSTEM_BATTERY_PATH.c_str());
183 if (dir == nullptr) {
184 BATTERY_HILOGE(LABEL_TEST, "cannot open POWER_SUPPLY_BASE_PATH");
185 return HDF_ERR_IO;
186 }
187
188 while (true) {
189 entry = readdir(dir);
190 if (entry == nullptr) {
191 break;
192 }
193
194 if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
195 continue;
196 }
197
198 if (entry->d_type == DT_DIR || entry->d_type == DT_LNK) {
199 BATTERY_HILOGI(LABEL_TEST, "init sysfs info of %{public}s", entry->d_name);
200 if (index >= MAX_SYSFS_SIZE) {
201 BATTERY_HILOGE(LABEL_TEST, "too many plugged types");
202 break;
203 }
204 g_filenodeName.emplace_back(entry->d_name);
205 index++;
206 }
207 }
208
209 TraversalBaseNode();
210 BATTERY_HILOGI(LABEL_TEST, "index is %{public}d", index);
211 closedir(dir);
212
213 return HDF_SUCCESS;
214 }
215
ReadTemperatureSysfs()216 static int32_t ReadTemperatureSysfs()
217 {
218 int strlen = 10;
219 char buf[128] = {0};
220 int32_t readSize;
221 InitBaseSysfs();
222 std::string tempNode = "battery";
223 for (auto iter = g_nodeInfo.begin(); iter != g_nodeInfo.end(); ++iter) {
224 if (iter->first == "temp") {
225 tempNode = iter->second;
226 break;
227 }
228 }
229 std::string sysBattTemPath = SYSTEM_BATTERY_PATH + "/" + tempNode + "/" + "temp";
230
231 int fd = open(sysBattTemPath.c_str(), O_RDONLY);
232 if (fd < NUM_ZERO) {
233 BATTERY_HILOGE(LABEL_TEST, "failed to open TemperatureSysfs");
234 return HDF_FAILURE;
235 }
236
237 readSize = read(fd, buf, sizeof(buf) - 1);
238 if (readSize < NUM_ZERO) {
239 BATTERY_HILOGE(LABEL_TEST, "failed to read TemperatureSysfs");
240 close(fd);
241 return HDF_FAILURE;
242 }
243
244 buf[readSize] = '\0';
245 int32_t battTemperature = strtol(buf, nullptr, strlen);
246 if (battTemperature < NUM_ZERO) {
247 BATTERY_HILOGE(LABEL_TEST, "read system file temperature is %{public}d", battTemperature);
248 }
249 BATTERY_HILOGE(LABEL_TEST, "read system file temperature is %{public}d", battTemperature);
250 close(fd);
251 return battTemperature;
252 }
253
ReadVoltageSysfs()254 static int32_t ReadVoltageSysfs()
255 {
256 int strlen = 10;
257 char buf[128] = {0};
258 int32_t readSize;
259 std::string voltageNode = "battery";
260 for (auto iter = g_nodeInfo.begin(); iter != g_nodeInfo.end(); ++iter) {
261 if (iter->first == "voltage_now") {
262 voltageNode = iter->second;
263 break;
264 }
265 }
266 std::string sysBattVolPath = SYSTEM_BATTERY_PATH + "/" + voltageNode + "/" + "voltage_now";
267
268 int fd = open(sysBattVolPath.c_str(), O_RDONLY);
269 if (fd < NUM_ZERO) {
270 BATTERY_HILOGE(LABEL_TEST, "failed to open VoltageSysfs");
271 return HDF_FAILURE;
272 }
273
274 readSize = read(fd, buf, sizeof(buf) - 1);
275 if (readSize < HDF_SUCCESS) {
276 BATTERY_HILOGE(LABEL_TEST, "failed to read VoltageSysfs");
277 close(fd);
278 return HDF_FAILURE;
279 }
280
281 buf[readSize] = '\0';
282 int32_t battVoltage = strtol(buf, nullptr, strlen);
283 if (battVoltage < NUM_ZERO) {
284 BATTERY_HILOGE(LABEL_TEST, "read system file voltage is %{public}d", battVoltage);
285 }
286 BATTERY_HILOGE(LABEL_TEST, "read system file voltage is %{public}d", battVoltage);
287 close(fd);
288 return battVoltage;
289 }
290
ReadCapacitySysfs()291 static int32_t ReadCapacitySysfs()
292 {
293 int strlen = 10;
294 char buf[128] = {0};
295 int32_t readSize;
296 std::string capacityNode = "battery";
297 for (auto iter = g_nodeInfo.begin(); iter != g_nodeInfo.end(); ++iter) {
298 if (iter->first == "capacity") {
299 capacityNode = iter->second;
300 break;
301 }
302 }
303 std::string sysBattCapPath = SYSTEM_BATTERY_PATH + "/" + capacityNode + "/" + "capacity";
304
305 int fd = open(sysBattCapPath.c_str(), O_RDONLY);
306 if (fd < NUM_ZERO) {
307 BATTERY_HILOGE(LABEL_TEST, "failed to open CapacitySysfs");
308 return HDF_FAILURE;
309 }
310
311 readSize = read(fd, buf, sizeof(buf) - 1);
312 if (readSize < NUM_ZERO) {
313 BATTERY_HILOGE(LABEL_TEST, "failed to read CapacitySysfs");
314 close(fd);
315 return HDF_FAILURE;
316 }
317
318 buf[readSize] = '\0';
319 int32_t battCapacity = strtol(buf, nullptr, strlen);
320 if (battCapacity < NUM_ZERO) {
321 BATTERY_HILOGE(LABEL_TEST, "read system file capacity is %{public}d", battCapacity);
322 }
323 BATTERY_HILOGE(LABEL_TEST, "read system file capacity is %{public}d", battCapacity);
324 close(fd);
325 return battCapacity;
326 }
327
ReadTotalEnergySysfs()328 static int32_t ReadTotalEnergySysfs()
329 {
330 int strlen = 10;
331 char buf[128] = {0};
332 int32_t readSize;
333 InitBaseSysfs();
334 std::string totalEnergyNode = "battery";
335 for (auto iter = g_nodeInfo.begin(); iter != g_nodeInfo.end(); ++iter) {
336 if (iter->first == "charge_full") {
337 totalEnergyNode = iter->second;
338 break;
339 }
340 }
341 std::string sysBattTotalEnergyPath = SYSTEM_BATTERY_PATH + "/" + totalEnergyNode + "/" + "charge_full";
342
343 int fd = open(sysBattTotalEnergyPath.c_str(), O_RDONLY);
344 if (fd < NUM_ZERO) {
345 BATTERY_HILOGE(LABEL_TEST, "failed to open TotalEnergySysfs");
346 return HDF_FAILURE;
347 }
348
349 readSize = read(fd, buf, sizeof(buf) - 1);
350 if (readSize < NUM_ZERO) {
351 BATTERY_HILOGE(LABEL_TEST, "failed to read TotalEnergySysfs");
352 close(fd);
353 return HDF_FAILURE;
354 }
355
356 buf[readSize] = '\0';
357 int32_t totalEnergy = strtol(buf, nullptr, strlen);
358 if (totalEnergy < NUM_ZERO) {
359 BATTERY_HILOGE(LABEL_TEST, "read system file totalEnergy is %{public}d", totalEnergy);
360 }
361 BATTERY_HILOGE(LABEL_TEST, "read system file totalEnergy is %{public}d", totalEnergy);
362 close(fd);
363 return totalEnergy;
364 }
365
ReadCurrentAverageSysfs()366 static int32_t ReadCurrentAverageSysfs()
367 {
368 int strlen = 10;
369 char buf[128] = {0};
370 int32_t readSize;
371 InitBaseSysfs();
372 std::string currentAvgNode = "battery";
373 for (auto iter = g_nodeInfo.begin(); iter != g_nodeInfo.end(); ++iter) {
374 if (iter->first == "current_avg") {
375 currentAvgNode = iter->second;
376 break;
377 }
378 }
379 std::string sysBattCurrentAvgPath = SYSTEM_BATTERY_PATH + "/" + currentAvgNode + "/" + "current_avg";
380
381 int fd = open(sysBattCurrentAvgPath.c_str(), O_RDONLY);
382 if (fd < NUM_ZERO) {
383 BATTERY_HILOGE(LABEL_TEST, "failed to open CurrentAverageSysfs");
384 return HDF_FAILURE;
385 }
386
387 readSize = read(fd, buf, sizeof(buf) - 1);
388 if (readSize < NUM_ZERO) {
389 BATTERY_HILOGE(LABEL_TEST, "failed to read CurrentAverageSysfs");
390 close(fd);
391 return HDF_FAILURE;
392 }
393
394 buf[readSize] = '\0';
395 int32_t currentAvg = strtol(buf, nullptr, strlen);
396 if (currentAvg < NUM_ZERO) {
397 BATTERY_HILOGE(LABEL_TEST, "read system file currentAvg is %{public}d", currentAvg);
398 }
399 BATTERY_HILOGE(LABEL_TEST, "read system file currentAvg is %{public}d", currentAvg);
400 close(fd);
401 return currentAvg;
402 }
403
ReadCurrentNowSysfs()404 static int32_t ReadCurrentNowSysfs()
405 {
406 int strlen = 10;
407 char buf[128] = {0};
408 int32_t readSize;
409 InitBaseSysfs();
410 std::string currentNowNode = "battery";
411 for (auto iter = g_nodeInfo.begin(); iter != g_nodeInfo.end(); ++iter) {
412 if (iter->first == "current_now") {
413 currentNowNode = iter->second;
414 break;
415 }
416 }
417 std::string sysBattCurrentNowPath = SYSTEM_BATTERY_PATH + "/" + currentNowNode + "/" + "current_now";
418
419 int fd = open(sysBattCurrentNowPath.c_str(), O_RDONLY);
420 if (fd < NUM_ZERO) {
421 BATTERY_HILOGE(LABEL_TEST, "failed to open CurrentNowSysfs");
422 return HDF_FAILURE;
423 }
424
425 readSize = read(fd, buf, sizeof(buf) - 1);
426 if (readSize < NUM_ZERO) {
427 BATTERY_HILOGE(LABEL_TEST, "failed to read CurrentNowSysfs");
428 close(fd);
429 return HDF_FAILURE;
430 }
431
432 buf[readSize] = '\0';
433 int32_t currentNow = strtol(buf, nullptr, strlen);
434 if (currentNow < NUM_ZERO) {
435 BATTERY_HILOGE(LABEL_TEST, "read system file currentNow is %{public}d", currentNow);
436 }
437 BATTERY_HILOGE(LABEL_TEST, "read system file currentNow is %{public}d", currentNow);
438 close(fd);
439 return currentNow;
440 }
441
ReadRemainEnergySysfs()442 static int32_t ReadRemainEnergySysfs()
443 {
444 int strlen = 10;
445 char buf[128] = {0};
446 int32_t readSize;
447 InitBaseSysfs();
448 std::string chargeNowNode = "battery";
449 for (auto iter = g_nodeInfo.begin(); iter != g_nodeInfo.end(); ++iter) {
450 if (iter->first == "charge_now") {
451 chargeNowNode = iter->second;
452 break;
453 }
454 }
455 std::string sysBattChargeNowPath = SYSTEM_BATTERY_PATH + "/" + chargeNowNode + "/" + "charge_now";
456
457 int fd = open(sysBattChargeNowPath.c_str(), O_RDONLY);
458 if (fd < NUM_ZERO) {
459 BATTERY_HILOGE(LABEL_TEST, "failed to open RemainEnergySysfs");
460 return HDF_FAILURE;
461 }
462
463 readSize = read(fd, buf, sizeof(buf) - 1);
464 if (readSize < NUM_ZERO) {
465 BATTERY_HILOGE(LABEL_TEST, "failed to read RemainEnergySysfs");
466 close(fd);
467 return HDF_FAILURE;
468 }
469
470 buf[readSize] = '\0';
471 int32_t chargeNow = strtol(buf, nullptr, strlen);
472 if (chargeNow < NUM_ZERO) {
473 BATTERY_HILOGE(LABEL_TEST, "read system file chargeNow is %{public}d", chargeNow);
474 }
475 BATTERY_HILOGE(LABEL_TEST, "read system file chargeNow is %{public}d", chargeNow);
476 close(fd);
477 return chargeNow;
478 }
479
Trim(char * str)480 static void Trim(char* str)
481 {
482 if (str == nullptr) {
483 return;
484 }
485 str[strcspn(str, "\n")] = 0;
486 }
487
HealthStateEnumConverter(const char * str)488 static int32_t HealthStateEnumConverter(const char* str)
489 {
490 struct StringEnumMap healthStateEnumMap[] = {
491 { "Good", PowerSupplyProvider::BATTERY_HEALTH_GOOD },
492 { "Cold", PowerSupplyProvider::BATTERY_HEALTH_COLD },
493 { "Warm", PowerSupplyProvider::BATTERY_HEALTH_GOOD }, // JEITA specification
494 { "Cool", PowerSupplyProvider::BATTERY_HEALTH_GOOD }, // JEITA specification
495 { "Hot", PowerSupplyProvider::BATTERY_HEALTH_OVERHEAT }, // JEITA specification
496 { "Overheat", PowerSupplyProvider::BATTERY_HEALTH_OVERHEAT },
497 { "Over voltage", PowerSupplyProvider::BATTERY_HEALTH_OVERVOLTAGE },
498 { "Dead", PowerSupplyProvider::BATTERY_HEALTH_DEAD },
499 { "Unknown", PowerSupplyProvider::BATTERY_HEALTH_UNKNOWN },
500 { "Unspecified failure", PowerSupplyProvider::BATTERY_HEALTH_UNKNOWN },
501 { NULL, PowerSupplyProvider::BATTERY_HEALTH_UNKNOWN },
502 };
503
504 for (int i = 0; healthStateEnumMap[i].str; ++i) {
505 if (strcmp(str, healthStateEnumMap[i].str) == 0) {
506 return healthStateEnumMap[i].enumVal;
507 }
508 }
509
510 return PowerSupplyProvider::BATTERY_HEALTH_UNKNOWN;
511 }
512
ReadHealthStateSysfs()513 static int32_t ReadHealthStateSysfs()
514 {
515 char buf[128] = {0};
516 int32_t readSize;
517 std::string healthNode = "battery";
518 for (auto iter = g_nodeInfo.begin(); iter != g_nodeInfo.end(); ++iter) {
519 if (iter->first == "health") {
520 healthNode = iter->second;
521 break;
522 }
523 }
524 std::string sysHealthStatePath = SYSTEM_BATTERY_PATH + "/" + healthNode + "/" + "health";
525
526 int fd = open(sysHealthStatePath.c_str(), O_RDONLY);
527 if (fd < NUM_ZERO) {
528 BATTERY_HILOGE(LABEL_TEST, "failed to open HealthStateSysfs");
529 return HDF_FAILURE;
530 }
531
532 readSize = read(fd, buf, sizeof(buf) - 1);
533 if (readSize < NUM_ZERO) {
534 BATTERY_HILOGE(LABEL_TEST, "failed to read HealthStateSysfs");
535 close(fd);
536 return HDF_FAILURE;
537 }
538
539 Trim(buf);
540
541 int32_t battHealthState = HealthStateEnumConverter(buf);
542 BATTERY_HILOGE(LABEL_TEST, "read system file healthState is %{public}d", battHealthState);
543 close(fd);
544 return battHealthState;
545 }
546
PluggedTypeEnumConverter(const char * str)547 static int32_t PluggedTypeEnumConverter(const char* str)
548 {
549 struct StringEnumMap pluggedTypeEnumMap[] = {
550 { "USB", PowerSupplyProvider::PLUGGED_TYPE_USB },
551 { "USB_PD_DRP", PowerSupplyProvider::PLUGGED_TYPE_USB },
552 { "Wireless", PowerSupplyProvider::PLUGGED_TYPE_WIRELESS },
553 { "Mains", PowerSupplyProvider::PLUGGED_TYPE_AC },
554 { "UPS", PowerSupplyProvider::PLUGGED_TYPE_AC },
555 { "USB_ACA", PowerSupplyProvider::PLUGGED_TYPE_AC },
556 { "USB_C", PowerSupplyProvider::PLUGGED_TYPE_AC },
557 { "USB_CDP", PowerSupplyProvider::PLUGGED_TYPE_AC },
558 { "USB_DCP", PowerSupplyProvider::PLUGGED_TYPE_AC },
559 { "USB_HVDCP", PowerSupplyProvider::PLUGGED_TYPE_AC },
560 { "USB_PD", PowerSupplyProvider::PLUGGED_TYPE_AC },
561 { "Unknown", PowerSupplyProvider::PLUGGED_TYPE_BUTT },
562 { NULL, PowerSupplyProvider::PLUGGED_TYPE_BUTT },
563 };
564
565 for (int i = 0; pluggedTypeEnumMap[i].str; ++i) {
566 if (strcmp(str, pluggedTypeEnumMap[i].str) == 0) {
567 return pluggedTypeEnumMap[i].enumVal;
568 }
569 }
570
571 return PowerSupplyProvider::PLUGGED_TYPE_BUTT;
572 }
573
ReadSysfsFile(const char * path,char * buf,size_t size)574 int32_t ReadSysfsFile(const char* path, char* buf, size_t size)
575 {
576 int fd = open(path, O_RDONLY, S_IRUSR | S_IRGRP | S_IROTH);
577 if (fd < NUM_ZERO) {
578 BATTERY_HILOGE(LABEL_TEST, "failed to open SysfsFile");
579 return HDF_ERR_IO;
580 }
581
582 int32_t readSize = read(fd, buf, size - 1);
583 if (readSize < NUM_ZERO) {
584 BATTERY_HILOGE(LABEL_TEST, "failed to read SysfsFile");
585 close(fd);
586 return HDF_ERR_IO;
587 }
588
589 buf[readSize] = '\0';
590 Trim(buf);
591 close(fd);
592
593 return HDF_SUCCESS;
594 }
595
ReadPluggedTypeSysfs()596 static int32_t ReadPluggedTypeSysfs()
597 {
598 std::string node = "USB";
599 int32_t online = ERROR;
600 char buf[MAX_BUFF_SIZE] = {0};
601
602 auto iter = g_filenodeName.begin();
603 while (iter != g_filenodeName.end()) {
604 if (strcasecmp(iter->c_str(), "battery") == 0) {
605 continue;
606 }
607 std::string onlinePath = SYSTEM_BATTERY_PATH + "/" + *iter + "/" + "online";
608 if (ReadSysfsFile(onlinePath.c_str(), buf, MAX_BUFF_SIZE) != HDF_SUCCESS) {
609 BATTERY_HILOGW(LABEL_TEST, "read online path failed in loop");
610 }
611 online = strtol(buf, nullptr, STR_TO_LONG_LEN);
612 if (online) {
613 node = *iter;
614 break;
615 }
616 iter++;
617 }
618 if (online == ERROR) {
619 return ERROR;
620 }
621 std::string typePath = SYSTEM_BATTERY_PATH + "/" + node + "/" + "type";
622 if (ReadSysfsFile(typePath.c_str(), buf, MAX_BUFF_SIZE) != HDF_SUCCESS) {
623 BATTERY_HILOGI(LABEL_TEST, "read type path failed");
624 return ERROR;
625 }
626 Trim(buf);
627 return PluggedTypeEnumConverter(buf);
628 }
629
ChargeStateEnumConverter(const char * str)630 int32_t ChargeStateEnumConverter(const char* str)
631 {
632 struct StringEnumMap chargeStateEnumMap[] = {
633 { "Discharging", PowerSupplyProvider::CHARGE_STATE_NONE },
634 { "Charging", PowerSupplyProvider::CHARGE_STATE_ENABLE },
635 { "Full", PowerSupplyProvider::CHARGE_STATE_FULL },
636 { "Not charging", PowerSupplyProvider::CHARGE_STATE_DISABLE },
637 { "Unknown", PowerSupplyProvider::CHARGE_STATE_RESERVED },
638 { NULL, PowerSupplyProvider::CHARGE_STATE_RESERVED },
639 };
640
641 for (int i = 0; chargeStateEnumMap[i].str; ++i) {
642 if (strcmp(str, chargeStateEnumMap[i].str) == 0) {
643 return chargeStateEnumMap[i].enumVal;
644 }
645 }
646 return PowerSupplyProvider::CHARGE_STATE_RESERVED;
647 }
648
ReadChargeStateSysfs()649 static int32_t ReadChargeStateSysfs()
650 {
651 char buf[128] = {0};
652 int32_t readSize;
653 std::string statusNode = "battery";
654 for (auto iter = g_nodeInfo.begin(); iter != g_nodeInfo.end(); ++iter) {
655 if (iter->first == "status") {
656 statusNode = iter->second;
657 break;
658 }
659 }
660 std::string sysChargeStatePath = SYSTEM_BATTERY_PATH + "/" + statusNode + "/" + "status";
661
662 int fd = open(sysChargeStatePath.c_str(), O_RDONLY);
663 if (fd < NUM_ZERO) {
664 BATTERY_HILOGE(LABEL_TEST, "failed to open ChargeStateSysfs");
665 return HDF_FAILURE;
666 }
667
668 readSize = read(fd, buf, sizeof(buf) - 1);
669 if (readSize < NUM_ZERO) {
670 BATTERY_HILOGE(LABEL_TEST, "failed to read ChargeStateSysfs");
671 close(fd);
672 return HDF_FAILURE;
673 }
674
675 Trim(buf);
676 int32_t battChargeState = ChargeStateEnumConverter(buf);
677 BATTERY_HILOGE(LABEL_TEST, "read system file chargeState is %{public}d", battChargeState);
678 close(fd);
679
680 return battChargeState;
681 }
682
ReadChargeCounterSysfs()683 static int32_t ReadChargeCounterSysfs()
684 {
685 int strlen = 10;
686 char buf[128] = {0};
687 int32_t readSize;
688 std::string counterNode = "battery";
689 for (auto iter = g_nodeInfo.begin(); iter != g_nodeInfo.end(); ++iter) {
690 if (iter->first == "charge_counter") {
691 counterNode = iter->second;
692 break;
693 }
694 }
695 std::string sysChargeCounterPath = SYSTEM_BATTERY_PATH + "/" + counterNode + "/" + "charge_counter";
696
697 int fd = open(sysChargeCounterPath.c_str(), O_RDONLY);
698 if (fd < NUM_ZERO) {
699 BATTERY_HILOGE(LABEL_TEST, "failed to open ChargeCounterSysfs");
700 return HDF_FAILURE;
701 }
702
703 readSize = read(fd, buf, sizeof(buf) - 1);
704 if (readSize < NUM_ZERO) {
705 BATTERY_HILOGE(LABEL_TEST, "failed to read ChargeCounterSysfs");
706 close(fd);
707 return HDF_FAILURE;
708 }
709
710 buf[readSize] = '\0';
711 int32_t battChargeCounter = strtol(buf, nullptr, strlen);
712 if (battChargeCounter < 0) {
713 BATTERY_HILOGE(LABEL_TEST, "read system file chargeState is %{public}d", battChargeCounter);
714 }
715 BATTERY_HILOGE(LABEL_TEST, "read system file chargeState is %{public}d", battChargeCounter);
716 close(fd);
717
718 return battChargeCounter;
719 }
720
ReadPresentSysfs()721 static int32_t ReadPresentSysfs()
722 {
723 int strlen = 10;
724 char buf[128] = {0};
725 int32_t readSize;
726 std::string presentNode = "battery";
727 for (auto iter = g_nodeInfo.begin(); iter != g_nodeInfo.end(); ++iter) {
728 if (iter->first == "present") {
729 presentNode = iter->second;
730 break;
731 }
732 }
733 std::string sysPresentPath = SYSTEM_BATTERY_PATH + "/" + presentNode + "/" + "present";
734
735 int fd = open(sysPresentPath.c_str(), O_RDONLY);
736 if (fd < NUM_ZERO) {
737 BATTERY_HILOGE(LABEL_TEST, "failed to open PresentSysfs");
738 return HDF_FAILURE;
739 }
740
741 readSize = read(fd, buf, sizeof(buf) - 1);
742 if (readSize < NUM_ZERO) {
743 BATTERY_HILOGE(LABEL_TEST, "failed to read PresentSysfs");
744 close(fd);
745 return HDF_FAILURE;
746 }
747
748 buf[readSize] = '\0';
749 int32_t battPresent = strtol(buf, nullptr, strlen);
750 if (battPresent < 0) {
751 BATTERY_HILOGE(LABEL_TEST, "read system file chargeState is %{public}d", battPresent);
752 }
753 BATTERY_HILOGE(LABEL_TEST, "read system file chargeState is %{public}d", battPresent);
754 close(fd);
755 return battPresent;
756 }
757
ReadTechnologySysfs(std::string & battTechnology)758 static std::string ReadTechnologySysfs(std::string& battTechnology)
759 {
760 char buf[128] = {0};
761 int32_t readSize;
762 std::string technologyNode = "battery";
763 for (auto iter = g_nodeInfo.begin(); iter != g_nodeInfo.end(); ++iter) {
764 if (iter->first == "technology") {
765 technologyNode = iter->second;
766 break;
767 }
768 }
769 std::string sysTechnologyPath = SYSTEM_BATTERY_PATH + "/" + technologyNode + "/" + "technology";
770
771 int fd = open(sysTechnologyPath.c_str(), O_RDONLY);
772 if (fd < NUM_ZERO) {
773 BATTERY_HILOGE(LABEL_TEST, "failed to open TechnologySysfs");
774 return "";
775 }
776
777 readSize = read(fd, buf, sizeof(buf) - 1);
778 if (readSize < NUM_ZERO) {
779 BATTERY_HILOGE(LABEL_TEST, "failed to read TechnologySysfs");
780 close(fd);
781 return "";
782 }
783 buf[readSize] = '\0';
784 Trim(buf);
785
786 battTechnology.assign(buf, strlen(buf));
787 BATTERY_HILOGE(LABEL_TEST, "read system file technology is %{public}s.", battTechnology.c_str());
788 close(fd);
789 return battTechnology;
790 }
791
IsNotMock()792 static bool IsNotMock()
793 {
794 bool rootExist = access(SYSTEM_BATTERY_PATH.c_str(), F_OK) == 0;
795 bool lowerExist = access((SYSTEM_BATTERY_PATH + "/battery").c_str(), F_OK) == 0;
796 bool upperExist = access((SYSTEM_BATTERY_PATH + "/Battery").c_str(), F_OK) == 0;
797 return rootExist && (lowerExist || upperExist);
798 }
799
800 /**
801 * @tc.name: ProviderIsNotNull
802 * @tc.desc: Test functions of PowerSupplyProvider
803 * @tc.type: FUNC
804 */
805 HWTEST_F (HdiServiceTest, ProviderIsNotNull, TestSize.Level1)
806 {
807 ASSERT_TRUE(giver_ != nullptr);
808 if (!IsNotMock()) {
809 giver_->SetSysFilePath(MOCK_BATTERY_PATH);
810 BATTERY_HILOGI(LABEL_TEST, "Is mock test");
811 }
812 giver_->InitPowerSupplySysfs();
813 }
814
815 /**
816 * @tc.name: HdiService001
817 * @tc.desc: Test functions of ParseTemperature
818 * @tc.type: FUNC
819 */
820 HWTEST_F (HdiServiceTest, HdiService001, TestSize.Level1)
821 {
822 int32_t temperature = 0;
823 if (IsNotMock()) {
824 giver_->ParseTemperature(&temperature);
825 int32_t sysfsTemp = ReadTemperatureSysfs();
826 BATTERY_HILOGI(LABEL_TEST, "Not Mock HdiService001::temperature=%{public}d, t=%{public}d",
827 temperature, sysfsTemp);
828 ASSERT_TRUE(temperature == sysfsTemp);
829 } else {
830 CreateFile(MOCK_BATTERY_PATH + "battery/temp", "567");
831 giver_->ParseTemperature(&temperature);
832 BATTERY_HILOGI(LABEL_TEST, "HdiService001::temperature=%{public}d.", temperature);
833 ASSERT_TRUE(temperature == 567);
834 }
835 }
836
837 /**
838 * @tc.name: HdiService002
839 * @tc.desc: Test functions of ParseVoltage
840 * @tc.type: FUNC
841 */
842 HWTEST_F (HdiServiceTest, HdiService002, TestSize.Level1)
843 {
844 int32_t voltage = 0;
845 if (IsNotMock()) {
846 giver_->ParseVoltage(&voltage);
847 int32_t sysfsVoltage = ReadVoltageSysfs();
848 BATTERY_HILOGI(LABEL_TEST, "Not Mock HdiService002::voltage=%{public}d, v=%{public}d",
849 voltage, sysfsVoltage);
850 ASSERT_TRUE(voltage == sysfsVoltage);
851 } else {
852 CreateFile(MOCK_BATTERY_PATH + "battery/voltage_avg", "4123456");
853 CreateFile(MOCK_BATTERY_PATH + "battery/voltage_now", "4123456");
854 giver_->ParseVoltage(&voltage);
855 BATTERY_HILOGI(LABEL_TEST, "Not Mock HdiService002::voltage=%{public}d", voltage);
856 ASSERT_TRUE(voltage == 4123456);
857 }
858 }
859
860 /**
861 * @tc.name: HdiService003
862 * @tc.desc: Test functions of ParseCapacity
863 * @tc.type: FUNC
864 */
865 HWTEST_F (HdiServiceTest, HdiService003, TestSize.Level1)
866 {
867 int32_t capacity = -1;
868 if (IsNotMock()) {
869 giver_->ParseCapacity(&capacity);
870 int32_t sysfsCapacity = ReadCapacitySysfs();
871 BATTERY_HILOGI(LABEL_TEST, "Not Mcok HdiService003::capacity=%{public}d, l=%{public}d",
872 capacity, sysfsCapacity);
873 ASSERT_TRUE(capacity == sysfsCapacity);
874 } else {
875 CreateFile(MOCK_BATTERY_PATH + "battery/capacity", "11");
876 giver_->ParseCapacity(&capacity);
877 BATTERY_HILOGI(LABEL_TEST, "HdiService003::capacity=%{public}d", capacity);
878 ASSERT_TRUE(capacity == 11);
879 }
880 }
881
882 /**
883 * @tc.name: HdiService004
884 * @tc.desc: Test functions of ParseHealthState
885 * @tc.type: FUNC
886 */
887 HWTEST_F (HdiServiceTest, HdiService004, TestSize.Level1)
888 {
889 int32_t healthState = -1;
890 if (IsNotMock()) {
891 giver_->ParseHealthState(&healthState);
892 int32_t sysfsHealthState = ReadHealthStateSysfs();
893 BATTERY_HILOGI(LABEL_TEST, "Not Mock HdiService004::healthState=%{public}d, h=%{public}d",
894 healthState, sysfsHealthState);
895 ASSERT_TRUE(healthState == sysfsHealthState);
896 } else {
897 CreateFile(MOCK_BATTERY_PATH + "battery/health", "Good");
898 giver_->ParseHealthState(&healthState);
899 BATTERY_HILOGI(LABEL_TEST, "HdiService004::healthState=%{public}d.", healthState);
900 ASSERT_TRUE(PowerSupplyProvider::BatteryHealthState(healthState) ==
901 PowerSupplyProvider::BatteryHealthState::BATTERY_HEALTH_GOOD);
902 }
903 }
904
905 /**
906 * @tc.name: HdiService005
907 * @tc.desc: Test functions of ParsePluggedType
908 * @tc.type: FUNC
909 */
910 HWTEST_F (HdiServiceTest, HdiService005, TestSize.Level1)
911 {
912 int32_t pluggedType = PowerSupplyProvider::PLUGGED_TYPE_NONE;
913 if (IsNotMock()) {
914 giver_->ParsePluggedType(&pluggedType);
915 int32_t sysfsPluggedType = ReadPluggedTypeSysfs();
916 BATTERY_HILOGI(LABEL_TEST, "Not Mock HdiService005::pluggedType=%{public}d, p=%{public}d",
917 pluggedType, sysfsPluggedType);
918 ASSERT_TRUE(pluggedType == sysfsPluggedType);
919 } else {
920 CreateFile(MOCK_BATTERY_PATH + "ohos_charger/online", "1");
921 CreateFile(MOCK_BATTERY_PATH + "ohos_charger/type", "Wireless");
922 giver_->ParsePluggedType(&pluggedType);
923 BATTERY_HILOGI(LABEL_TEST, "HdiService005::pluggedType=%{public}d.", pluggedType);
924 ASSERT_TRUE(PowerSupplyProvider::BatteryPluggedType(pluggedType) ==
925 PowerSupplyProvider::BatteryPluggedType::PLUGGED_TYPE_WIRELESS);
926 }
927 }
928
929 /**
930 * @tc.name: HdiService006
931 * @tc.desc: Test functions of ParseChargeState
932 * @tc.type: FUNC
933 */
934 HWTEST_F (HdiServiceTest, HdiService006, TestSize.Level1)
935 {
936 int32_t chargeState = PowerSupplyProvider::CHARGE_STATE_RESERVED;
937 if (IsNotMock()) {
938 giver_->ParseChargeState(&chargeState);
939 int32_t sysfsChargeState = ReadChargeStateSysfs();
940 BATTERY_HILOGI(LABEL_TEST, "Not Mock HdiService006::chargeState=%{public}d, cs=%{public}d",
941 chargeState, sysfsChargeState);
942 ASSERT_TRUE(chargeState == sysfsChargeState);
943 } else {
944 CreateFile(MOCK_BATTERY_PATH + "battery/status", "Not charging");
945 giver_->ParseChargeState(&chargeState);
946 BATTERY_HILOGI(LABEL_TEST, "HdiService006::chargeState=%{public}d.", chargeState);
947 ASSERT_TRUE(PowerSupplyProvider::BatteryChargeState(chargeState) ==
948 PowerSupplyProvider::BatteryChargeState::CHARGE_STATE_DISABLE);
949 }
950 }
951
952 /**
953 * @tc.name: HdiService007
954 * @tc.desc: Test functions of ParseChargeCounter
955 * @tc.type: FUNC
956 */
957 HWTEST_F (HdiServiceTest, HdiService007, TestSize.Level1)
958 {
959 int32_t chargeCounter = -1;
960 if (IsNotMock()) {
961 giver_->ParseChargeCounter(&chargeCounter);
962 int32_t sysfsChargeCounter = ReadChargeCounterSysfs();
963 BATTERY_HILOGI(LABEL_TEST, "Not Mcok HdiService007::chargeCounter=%{public}d, cc=%{public}d",
964 chargeCounter, sysfsChargeCounter);
965 ASSERT_TRUE(chargeCounter == sysfsChargeCounter);
966 } else {
967 CreateFile(MOCK_BATTERY_PATH + "battery/charge_counter", "12345");
968 giver_->ParseChargeCounter(&chargeCounter);
969 BATTERY_HILOGI(LABEL_TEST, "HdiService007::chargeCounter=%{public}d.", chargeCounter);
970 ASSERT_TRUE(chargeCounter == 12345);
971 }
972 }
973
974 /**
975 * @tc.name: HdiService008
976 * @tc.desc: Test functions of ParsePresent
977 * @tc.type: FUNC
978 */
979 HWTEST_F (HdiServiceTest, HdiService008, TestSize.Level1)
980 {
981 int8_t present = -1;
982 if (IsNotMock()) {
983 giver_->ParsePresent(&present);
984 int32_t sysfsPresent = ReadPresentSysfs();
985 BATTERY_HILOGI(LABEL_TEST, "Not Mock HdiService008::present=%{public}d, p=%{public}d",
986 present, sysfsPresent);
987 ASSERT_TRUE(present == sysfsPresent);
988 } else {
989 CreateFile(MOCK_BATTERY_PATH + "battery/present", "1");
990 giver_->ParsePresent(&present);
991 BATTERY_HILOGI(LABEL_TEST, "HdiService008::present=%{public}d.", present);
992 ASSERT_TRUE(present == 1);
993 }
994 }
995
996 /**
997 * @tc.name: HdiService009
998 * @tc.desc: Test functions to get value of technology
999 * @tc.type: FUNC
1000 */
1001 HWTEST_F (HdiServiceTest, HdiService009, TestSize.Level1)
1002 {
1003 std::string technology = "invalid";
1004 if (IsNotMock()) {
1005 giver_->ParseTechnology(technology);
1006 std::string sysfsTechnology = "";
1007 ReadTechnologySysfs(sysfsTechnology);
1008 BATTERY_HILOGI(LABEL_TEST, "HdiService009::technology=%{public}s, ty=%{public}s",
1009 technology.c_str(), sysfsTechnology.c_str());
1010 ASSERT_TRUE(technology == sysfsTechnology);
1011 } else {
1012 CreateFile(MOCK_BATTERY_PATH + "ohos-fgu/technology", "Li");
1013 giver_->ParseTechnology(technology);
1014 BATTERY_HILOGI(LABEL_TEST, "HdiService009::technology=%{public}s.", technology.c_str());
1015 ASSERT_TRUE(technology == "Li");
1016 }
1017 }
1018
1019 /**
1020 * @tc.name: HdiService010
1021 * @tc.desc: Test functions to get fd of socket
1022 * @tc.type: FUNC
1023 */
1024 HWTEST_F (HdiServiceTest, HdiService010, TestSize.Level1)
1025 {
1026 using namespace OHOS::HDI::Battery::V1_1;
1027
1028 BatteryThread bt;
1029 auto fd = OpenUeventSocketTest(bt);
1030 BATTERY_HILOGI(LABEL_TEST, "HdiService010::fd=%{public}d.", fd);
1031
1032 ASSERT_TRUE(fd > 0);
1033 close(fd);
1034 }
1035
1036 /**
1037 * @tc.name: HdiService011
1038 * @tc.desc: Test functions UpdateEpollInterval when charge-online
1039 * @tc.type: FUNC
1040 */
1041 HWTEST_F (HdiServiceTest, HdiService011, TestSize.Level1)
1042 {
1043 const int32_t CHARGE_STATE_ENABLE = 1;
1044 BatteryThread bt;
1045
1046 UpdateEpollIntervalTest(CHARGE_STATE_ENABLE, bt);
1047 auto epollInterval = GetEpollIntervalTest(bt);
1048 BATTERY_HILOGI(LABEL_TEST, "HdiService011::epollInterval=%{public}d.", epollInterval);
1049
1050 ASSERT_TRUE(epollInterval == 2000);
1051 }
1052
1053 /**
1054 * @tc.name: HdiService012
1055 * @tc.desc: Test functions UpdateEpollInterval when charge-offline
1056 * @tc.type: FUNC
1057 */
1058 HWTEST_F (HdiServiceTest, HdiService012, TestSize.Level1)
1059 {
1060 const int32_t CHARGE_STATE_NONE = 0;
1061 BatteryThread bt;
1062
1063 UpdateEpollIntervalTest(CHARGE_STATE_NONE, bt);
1064 auto epollInterval = GetEpollIntervalTest(bt);
1065 BATTERY_HILOGI(LABEL_TEST, "HdiService012::epollInterval=%{public}d.", epollInterval);
1066
1067 ASSERT_TRUE(epollInterval == -1);
1068 }
1069
1070 /**
1071 * @tc.name: HdiService013
1072 * @tc.desc: Test functions Init
1073 * @tc.type: FUNC
1074 */
1075 HWTEST_F (HdiServiceTest, HdiService013, TestSize.Level1)
1076 {
1077 void* service = nullptr;
1078 BatteryThread bt;
1079
1080 InitTest(service, bt);
1081 BATTERY_HILOGI(LABEL_TEST, "HdiService013::InitTest success");
1082 auto epollFd = GetEpollFdTest(bt);
1083 BATTERY_HILOGI(LABEL_TEST, "HdiService013::epollFd=%{public}d", epollFd);
1084
1085 ASSERT_TRUE(epollFd > 0);
1086 }
1087
1088 /**
1089 * @tc.name: HdiService020
1090 * @tc.desc: Test functions InitVibration in ChargerThread
1091 * @tc.type: FUNC
1092 */
1093 HWTEST_F (HdiServiceTest, HdiService020, TestSize.Level1)
1094 {
1095 std::unique_ptr<BatteryVibrate> vibrate = std::make_unique<BatteryVibrate>();
1096 const std::string VIBRATOR_PLAYMODE_PATH = "/sys/class/leds/vibrator/play_mode";
1097 const std::string VIBRATOR_DURATIONMODE_PATH = "/sys/class/leds/vibrator/duration";
1098 auto ret = vibrate->InitVibration();
1099 if ((access(VIBRATOR_PLAYMODE_PATH.c_str(), F_OK) == 0) ||
1100 (access(VIBRATOR_DURATIONMODE_PATH.c_str(), F_OK) == 0)) {
1101 ASSERT_TRUE(ret);
1102 } else {
1103 ASSERT_FALSE(ret);
1104 }
1105 }
1106
1107 /**
1108 * @tc.name: HdiService021
1109 * @tc.desc: Test functions CycleMatters in ChargerThread
1110 * @tc.type: FUNC
1111 */
1112 HWTEST_F (HdiServiceTest, HdiService021, TestSize.Level1)
1113 {
1114 ChargerThread ct;
1115
1116 ChargerThreadInitTest(ct);
1117 CycleMattersTest(ct);
1118 auto getBatteryInfo = GetBatteryInfoTest(ct);
1119
1120 ASSERT_TRUE(getBatteryInfo);
1121 }
1122
1123 /**
1124 * @tc.name: HdiService022
1125 * @tc.desc: Test functions HandleBacklight
1126 * @tc.type: FUNC
1127 */
1128 HWTEST_F (HdiServiceTest, HdiService022, TestSize.Level1)
1129 {
1130 std::unique_ptr<BatteryBacklight> backlight = std::make_unique<BatteryBacklight>();
1131 backlight->InitBacklightSysfs();
1132 auto ret = backlight->HandleBacklight(0);
1133 BATTERY_HILOGI(LABEL_TEST, "HdiService022::ret==%{public}d", ret);
1134 backlight->TurnOnScreen();
1135
1136 ASSERT_TRUE(ret != -1);
1137 }
1138
1139 /**
1140 * @tc.name: HdiService023
1141 * @tc.desc: Test functions of ParseTotalEnergy
1142 * @tc.type: FUNC
1143 */
1144 HWTEST_F (HdiServiceTest, HdiService023, TestSize.Level1)
1145 {
1146 int32_t totalEnergy = 0;
1147 if (IsNotMock()) {
1148 giver_->ParseTotalEnergy(&totalEnergy);
1149 int32_t sysfsTotalEnergy = ReadTotalEnergySysfs();
1150 BATTERY_HILOGI(LABEL_TEST, "Not Mock HdiService023::totalEnergy=%{public}d, t=%{public}d",
1151 totalEnergy, sysfsTotalEnergy);
1152 ASSERT_TRUE(totalEnergy == sysfsTotalEnergy);
1153 } else {
1154 CreateFile(MOCK_BATTERY_PATH + "battery/charge_full", "4000000");
1155 giver_->ParseTotalEnergy(&totalEnergy);
1156 BATTERY_HILOGI(LABEL_TEST, "HdiService023::totalEnergy=%{public}d.", totalEnergy);
1157 ASSERT_TRUE(totalEnergy == 4000000);
1158 }
1159 }
1160
1161 /**
1162 * @tc.name: HdiService024
1163 * @tc.desc: Test functions of ParseCurrentAverage
1164 * @tc.type: FUNC
1165 */
1166 HWTEST_F (HdiServiceTest, HdiService024, TestSize.Level1)
1167 {
1168 int32_t currentAvg = HDF_FAILURE;
1169 if (IsNotMock()) {
1170 giver_->ParseCurrentAverage(¤tAvg);
1171 int32_t sysfsCurrentAvg = ReadCurrentAverageSysfs();
1172 BATTERY_HILOGI(LABEL_TEST, "Not Mock HdiService024::currentAvg=%{public}d, t=%{public}d",
1173 currentAvg, sysfsCurrentAvg);
1174 ASSERT_TRUE(currentAvg == sysfsCurrentAvg);
1175 } else {
1176 CreateFile(MOCK_BATTERY_PATH + "battery/current_avg", "1000");
1177 giver_->ParseCurrentAverage(¤tAvg);
1178 BATTERY_HILOGI(LABEL_TEST, "HdiService024::currentAvg=%{public}d.", currentAvg);
1179 ASSERT_TRUE(currentAvg == 1000);
1180 }
1181 }
1182
1183 /**
1184 * @tc.name: HdiService025
1185 * @tc.desc: Test functions of ParseCurrentNow
1186 * @tc.type: FUNC
1187 */
1188 HWTEST_F (HdiServiceTest, HdiService025, TestSize.Level1)
1189 {
1190 int32_t currentNow = 0;
1191 if (IsNotMock()) {
1192 giver_->ParseCurrentNow(¤tNow);
1193 int32_t sysfsCurrentNow = ReadCurrentNowSysfs();
1194 BATTERY_HILOGI(LABEL_TEST, "Not Mock HdiService025::currentNow=%{public}d, t=%{public}d",
1195 currentNow, sysfsCurrentNow);
1196 ASSERT_TRUE(currentNow == sysfsCurrentNow);
1197 } else {
1198 CreateFile(MOCK_BATTERY_PATH + "battery/current_now", "1000");
1199 giver_->ParseCurrentNow(¤tNow);
1200 BATTERY_HILOGI(LABEL_TEST, "HdiService025::currentNow=%{public}d.", currentNow);
1201 ASSERT_TRUE(currentNow == 1000);
1202 }
1203 }
1204
1205 /**
1206 * @tc.name: HdiService026
1207 * @tc.desc: Test functions of ParseChargeNow
1208 * @tc.type: FUNC
1209 */
1210 HWTEST_F (HdiServiceTest, HdiService026, TestSize.Level1)
1211 {
1212 int32_t chargeNow = 0;
1213 if (IsNotMock()) {
1214 giver_->ParseRemainEnergy(&chargeNow);
1215 int32_t sysfsChargeNow = ReadRemainEnergySysfs();
1216 BATTERY_HILOGI(LABEL_TEST, "Not Mock HdiService026::chargeNow=%{public}d, t=%{public}d",
1217 chargeNow, sysfsChargeNow);
1218 ASSERT_TRUE(chargeNow == sysfsChargeNow);
1219 } else {
1220 CreateFile(MOCK_BATTERY_PATH + "battery/charge_now", "1000");
1221 giver_->ParseRemainEnergy(&chargeNow);
1222 BATTERY_HILOGI(LABEL_TEST, "HdiService026::chargeNow=%{public}d.", chargeNow);
1223 ASSERT_TRUE(chargeNow == 1000);
1224 }
1225 }
1226 }
1227