1 /*
2 * Copyright (c) 2021 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 "utils/hdf_log.h"
33 #include "power_supply_provider.h"
34 #include "battery_service.h"
35 #include "hdf_device_desc.h"
36 #include "battery_srv_client.h"
37 #include "battery_thread_test.h"
38 #include "animation_label.h"
39
40 using namespace testing::ext;
41 using namespace OHOS;
42 using namespace OHOS::PowerMgr;
43 using namespace OHOS::HDI::Battery::V1_0;
44 using namespace std;
45
46 static sptr<BatteryService> g_service;
47 static std::vector<std::string> g_ledsNodeName;
48 static const std::string LEDS_BASE_PATH = "/sys/class/leds";
49 static std::string g_redLedsNode = "red";
50 static std::string g_greenLedsNode = "green";
51 static std::string g_blueLedsNode = "blue";
52
SetUpTestCase(void)53 void BatterySttest::SetUpTestCase(void)
54 {
55 g_service = DelayedSpSingleton<BatteryService>::GetInstance();
56 g_service->OnStart();
57 }
58
TearDownTestCase(void)59 void BatterySttest::TearDownTestCase(void)
60 {
61 g_service->OnStop();
62 DelayedSpSingleton<BatteryService>::DestroyInstance();
63 }
64
SetUp(void)65 void BatterySttest::SetUp(void)
66 {
67 }
68
TearDown(void)69 void BatterySttest::TearDown(void)
70 {
71 }
72
CreateFile(std::string path,std::string content)73 std::string CreateFile(std::string path, std::string content)
74 {
75 HDF_LOGD("%{public}s: enter. CreateFile enter.", __func__);
76 std::ofstream stream(path.c_str());
77 if (!stream.is_open()) {
78 HDF_LOGD("%{public}s: enter, Cannot create file %{public}s", __func__, path.c_str());
79 return nullptr;
80 }
81 stream << content.c_str() << std::endl;
82 stream.close();
83 return path;
84 }
85
MockFileInit()86 static void MockFileInit()
87 {
88 std::string path = "/data/local/tmp";
89 mkdir("/data/local/tmp/battery", S_IRWXU);
90 mkdir("/data/local/tmp/ohos_charger", S_IRWXU);
91 mkdir("/data/local/tmp/ohos-fgu", S_IRWXU);
92 HDF_LOGD("%{public}s: enter.", __func__);
93
94 sleep(1);
95 CreateFile("/data/local/tmp/battery/online", "1");
96 CreateFile("/data/local/tmp/battery/type", "Battery");
97 CreateFile("/data/local/tmp/ohos_charger/health", "Unknown");
98 CreateFile("/data/local/tmp/ohos-fgu/temp", "345");
99
100 g_service->ChangePath(path);
101 }
102
TraversalNode()103 static void TraversalNode()
104 {
105 HDF_LOGD("%{public}s: enter", __func__);
106 string::size_type idx;
107
108 for (auto iter = g_ledsNodeName.begin(); iter != g_ledsNodeName.end(); ++iter) {
109 idx = iter->find(g_redLedsNode);
110 if (idx == string::npos) {
111 HDF_LOGD("%{public}s: not found red leds node", __func__);
112 } else {
113 g_redLedsNode = *iter;
114 HDF_LOGD("%{public}s: red leds node is %{public}s", __func__, iter->c_str());
115 }
116
117 idx = iter->find(g_greenLedsNode);
118 if (idx == string::npos) {
119 HDF_LOGD("%{public}s: not found green leds node", __func__);
120 } else {
121 g_greenLedsNode = *iter;
122 HDF_LOGD("%{public}s: green leds node is %{public}s", __func__, iter->c_str());
123 }
124
125 idx = iter->find(g_blueLedsNode);
126 if (idx == string::npos) {
127 HDF_LOGD("%{public}s: not found blue leds node", __func__);
128 } else {
129 g_blueLedsNode = *iter;
130 HDF_LOGD("%{public}s: blue leds node is %{public}s", __func__, iter->c_str());
131 }
132 }
133
134 HDF_LOGD("%{public}s: exit", __func__);
135 }
136
InitLedsSysfs(void)137 static int32_t InitLedsSysfs(void)
138 {
139 HDF_LOGI("%{public}s enter", __func__);
140 DIR* dir = nullptr;
141 struct dirent* entry = nullptr;
142 int32_t index = 0;
143 int maxSize = 64;
144
145 dir = opendir(LEDS_BASE_PATH.c_str());
146 if (dir == nullptr) {
147 HDF_LOGE("%{public}s: leds base path is not exist", __func__);
148 return HDF_ERR_IO;
149 }
150
151 while (true) {
152 entry = readdir(dir);
153 if (entry == nullptr) {
154 break;
155 }
156
157 if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
158 continue;
159 }
160
161 if (entry->d_type == DT_DIR || entry->d_type == DT_LNK) {
162 HDF_LOGD("%{public}s: init leds info of %{public}s", __func__, entry->d_name);
163 if (index >= maxSize) {
164 HDF_LOGE("%{public}s: too many leds types", __func__);
165 break;
166 }
167 g_ledsNodeName.emplace_back(entry->d_name);
168 index++;
169 }
170 }
171
172 TraversalNode();
173 HDF_LOGD("%{public}s: index is %{public}d", __func__, index);
174 closedir(dir);
175
176 HDF_LOGI("%{public}s exit", __func__);
177 return HDF_SUCCESS;
178 }
179
ReadRedLedSysfs()180 static int32_t ReadRedLedSysfs()
181 {
182 HDF_LOGD("%{public}s: enter", __func__);
183 int strlen = 10;
184 char buf[128] = {0};
185 int32_t readSize;
186 std::string redLedPath = "/data/local/tmp/leds/sc27xx:red/brightness";
187 std::string sysRedLedPath = LEDS_BASE_PATH + "/" + g_redLedsNode + "/" + "brightness";
188
189 int fd = open(sysRedLedPath.c_str(), O_RDWR);
190 if (fd < HDF_SUCCESS) {
191 HDF_LOGE("%{public}s: failed to open sys red led path %{public}s", __func__, g_redLedsNode.c_str());
192 fd = open(redLedPath.c_str(), O_RDWR);
193 if (fd < HDF_SUCCESS) {
194 HDF_LOGE("%{public}s: failed to open created red led path %{public}s", __func__, redLedPath.c_str());
195 return -1;
196 }
197 }
198
199 readSize = read(fd, buf, sizeof(buf) - 1);
200 if (readSize < HDF_SUCCESS) {
201 HDF_LOGE("%{public}s: failed to read %{public}s", __func__, redLedPath.c_str());
202 close(fd);
203 }
204
205 buf[readSize] = '\0';
206 int32_t redcolor = strtol(buf, nullptr, strlen);
207 close(fd);
208
209 HDF_LOGE("%{public}s: read redcolor value is %{public}d", __func__, redcolor);
210 return redcolor;
211 }
212
ReadGreenLedSysfs()213 static int32_t ReadGreenLedSysfs()
214 {
215 HDF_LOGD("%{public}s: enter", __func__);
216 int strlen = 10;
217 char buf[128] = {0};
218 int32_t readSize;
219 std::string greenLedPath = "/data/local/tmp/leds/sc27xx:green/brightness";
220 std::string sysGreenLedPath = LEDS_BASE_PATH + "/" + g_greenLedsNode + "/" + "brightness";
221
222 int fd = open(sysGreenLedPath.c_str(), O_RDWR);
223 if (fd < HDF_SUCCESS) {
224 HDF_LOGE("%{public}s: failed to open sys green led path %{public}s", __func__, g_greenLedsNode.c_str());
225 fd = open(greenLedPath.c_str(), O_RDWR);
226 if (fd < HDF_SUCCESS) {
227 HDF_LOGE("%{public}s: failed to open created green led path %{public}s", __func__, greenLedPath.c_str());
228 return -1;
229 }
230 }
231
232 readSize = read(fd, buf, sizeof(buf) - 1);
233 if (readSize < HDF_SUCCESS) {
234 HDF_LOGE("%{public}s: failed to read %{public}s", __func__, greenLedPath.c_str());
235 close(fd);
236 }
237
238 buf[readSize] = '\0';
239 int32_t greencolor = strtol(buf, nullptr, strlen);
240 close(fd);
241
242 HDF_LOGE("%{public}s: read greencolor value is %{public}d", __func__, greencolor);
243 return greencolor;
244 }
245
ReadBlueLedSysfs()246 static int32_t ReadBlueLedSysfs()
247 {
248 HDF_LOGD("%{public}s: enter", __func__);
249 int strlen = 10;
250 char buf[128] = {0};
251 int32_t readSize;
252 std::string blueLedPath = "/data/local/tmp/leds/sc27xx:blue/brightness";
253 std::string sysBlueLedPath = LEDS_BASE_PATH + "/" + g_blueLedsNode + "/" + "brightness";
254
255 int fd = open(sysBlueLedPath.c_str(), O_RDWR);
256 if (fd < HDF_SUCCESS) {
257 HDF_LOGE("%{public}s: failed to open sys blue led path %{public}s", __func__, g_blueLedsNode.c_str());
258 fd = open(blueLedPath.c_str(), O_RDWR);
259 if (fd < HDF_SUCCESS) {
260 HDF_LOGE("%{public}s: failed to open created blue led path %{public}s", __func__, blueLedPath.c_str());
261 return -1;
262 }
263 }
264
265 readSize = read(fd, buf, sizeof(buf) - 1);
266 if (readSize < HDF_SUCCESS) {
267 HDF_LOGE("%{public}s: failed to read %{public}s", __func__, blueLedPath.c_str());
268 close(fd);
269 }
270
271 buf[readSize] = '\0';
272 int32_t bluecolor = strtol(buf, nullptr, strlen);
273 close(fd);
274
275 HDF_LOGE("%{public}s: read bluecolor value is %{public}d", __func__, bluecolor);
276 return bluecolor;
277 }
278
279 /**
280 * @tc.name: BatteryST001
281 * @tc.desc: Test functions of HDI Interface GetTemperature
282 * @tc.type: FUNC
283 */
284 static HWTEST_F (BatterySttest, BatteryST001, TestSize.Level1)
285 {
286 HDF_LOGD("%{public}s: enter. BatteryST001 start.", __func__);
287 MockFileInit();
288 CreateFile("/data/local/tmp/battery/temp", "567");
289
290 auto temperature = g_service->GetBatteryTemperature();
291 HDF_LOGD("%{public}s: enter. BatteryST001::temperature=%{public}d.", __func__, temperature);
292
293 ASSERT_TRUE(temperature == 567);
294 HDF_LOGD("%{public}s: enter. BatteryST001 end.", __func__);
295 }
296
297 /**
298 * @tc.name: BatteryST002
299 * @tc.desc: Test functions of HDI Interface GetVoltage
300 * @tc.type: FUNC
301 */
302 HWTEST_F (BatterySttest, BatteryST002, TestSize.Level1)
303 {
304 HDF_LOGD("%{public}s: enter. BatteryST002 start.", __func__);
305 CreateFile("/data/local/tmp/battery/voltage_avg", "4123456");
306 CreateFile("/data/local/tmp/battery/voltage_now", "4123456");
307
308 auto voltage = g_service->GetVoltage();
309 HDF_LOGD("%{public}s: enter. BatteryST002::voltage=%{public}d.", __func__, voltage);
310
311 ASSERT_TRUE(voltage == 4123456);
312 HDF_LOGD("%{public}s: enter. BatteryST002 end.", __func__);
313 }
314
315 /**
316 * @tc.name: BatteryST003
317 * @tc.desc: Test functions of HDI Interface GetCapacity
318 * @tc.type: FUNC
319 */
320 HWTEST_F (BatterySttest, BatteryST003, TestSize.Level1)
321 {
322 HDF_LOGD("%{public}s: enter. BatteryST003 start.", __func__);
323 CreateFile("/data/local/tmp/battery/capacity", "11");
324
325 auto capacity = g_service->GetCapacity();
326 HDF_LOGD("%{public}s: enter. BatteryST003::capacity=%{public}d.", __func__, capacity);
327
328 ASSERT_TRUE(capacity == 11);
329 HDF_LOGD("%{public}s: enter. BatteryST003 end.", __func__);
330 }
331
332 /**
333 * @tc.name: BatteryST004
334 * @tc.desc: Test functions of HDI Interface GetHealthState when state is "Good"
335 * @tc.type: FUNC
336 */
337 HWTEST_F (BatterySttest, BatteryST004, TestSize.Level1)
338 {
339 HDF_LOGD("%{public}s: enter. BatteryST004 start.", __func__);
340 CreateFile("/data/local/tmp/battery/health", "Good");
341
342 auto healthState = g_service->GetHealthStatus();
343 HDF_LOGD("%{public}s: enter. BatteryST004::healthState=%{public}d.", __func__, healthState);
344
345 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
346 HDF_LOGD("%{public}s: enter. BatteryST004 end.", __func__);
347 }
348
349 /**
350 * @tc.name: BatteryST005
351 * @tc.desc: Test functions of HDI Interface GetHealthState when state is "Cold"
352 * @tc.type: FUNC
353 */
354 HWTEST_F (BatterySttest, BatteryST005, TestSize.Level1)
355 {
356 HDF_LOGD("%{public}s: enter. BatteryST005 start.", __func__);
357 CreateFile("/data/local/tmp/battery/health", "Cold");
358
359 auto healthState = g_service->GetHealthStatus();
360 HDF_LOGD("%{public}s: enter. BatteryST005::healthState=%{public}d.", __func__, healthState);
361
362 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_COLD);
363 HDF_LOGD("%{public}s: enter. BatteryST005 end.", __func__);
364 }
365
366 /**
367 * @tc.name: BatteryST006
368 * @tc.desc: Test functions of HDI Interface GetHealthState when state is "Warm"
369 * @tc.type: FUNC
370 */
371 HWTEST_F (BatterySttest, BatteryST006, TestSize.Level1)
372 {
373 HDF_LOGD("%{public}s: enter. BatteryST006 start.", __func__);
374 CreateFile("/data/local/tmp/battery/health", "Warm");
375
376 auto healthState = g_service->GetHealthStatus();
377 HDF_LOGD("%{public}s: enter. BatteryST006::healthState=%{public}d.", __func__, healthState);
378
379 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
380 HDF_LOGD("%{public}s: enter. BatteryST006 end.", __func__);
381 }
382
383 /**
384 * @tc.name: BatteryST007
385 * @tc.desc: Test functions of HDI Interface GetHealthState when state is "Cool"
386 * @tc.type: FUNC
387 */
388 HWTEST_F (BatterySttest, BatteryST007, TestSize.Level1)
389 {
390 HDF_LOGD("%{public}s: enter. BatteryST007 start.", __func__);
391 CreateFile("/data/local/tmp/battery/health", "Cool");
392
393 auto healthState = g_service->GetHealthStatus();
394 HDF_LOGD("%{public}s: enter. BatteryST007::healthState=%{public}d.", __func__, healthState);
395
396 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
397 HDF_LOGD("%{public}s: enter. BatteryST007 end.", __func__);
398 }
399
400 /**
401 * @tc.name: BatteryST008
402 * @tc.desc: Test functions of HDI Interface GetHealthState when state is "Hot"
403 * @tc.type: FUNC
404 */
405 HWTEST_F (BatterySttest, BatteryST008, TestSize.Level1)
406 {
407 HDF_LOGD("%{public}s: enter. BatteryST008 start.", __func__);
408 CreateFile("/data/local/tmp/battery/health", "Hot");
409
410 auto healthState = g_service->GetHealthStatus();
411 HDF_LOGD("%{public}s: enter. BatteryST008::healthState=%{public}d.", __func__, healthState);
412
413 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_OVERHEAT);
414 HDF_LOGD("%{public}s: enter. BatteryST008 end.", __func__);
415 }
416
417 /**
418 * @tc.name: BatteryST009
419 * @tc.desc: Test functions of HDI Interface GetHealthState when state is "Overheat"
420 * @tc.type: FUNC
421 */
422 HWTEST_F (BatterySttest, BatteryST009, TestSize.Level1)
423 {
424 HDF_LOGD("%{public}s: enter. BatteryST009 start.", __func__);
425 CreateFile("/data/local/tmp/battery/health", "Overheat");
426
427 auto healthState = g_service->GetHealthStatus();
428 HDF_LOGD("%{public}s: enter. BatteryST009::healthState=%{public}d.", __func__, healthState);
429
430 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_OVERHEAT);
431 HDF_LOGD("%{public}s: enter. BatteryST009 end.", __func__);
432 }
433
434 /**
435 * @tc.name: BatteryST010
436 * @tc.desc: Test functions of HDI Interface GetHealthState when state is "Over voltage"
437 * @tc.type: FUNC
438 */
439 HWTEST_F (BatterySttest, BatteryST010, TestSize.Level1)
440 {
441 HDF_LOGD("%{public}s: enter. BatteryST010 start.", __func__);
442 CreateFile("/data/local/tmp/battery/health", "Over voltage");
443
444 auto healthState = g_service->GetHealthStatus();
445 HDF_LOGD("%{public}s: enter. BatteryST010::healthState=%{public}d.", __func__, healthState);
446
447 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_OVERVOLTAGE);
448 HDF_LOGD("%{public}s: enter. BatteryST010 end.", __func__);
449 }
450
451 /**
452 * @tc.name: BatteryST011
453 * @tc.desc: Test functions of HDI Interface GetHealthState when state is "Dead"
454 * @tc.type: FUNC
455 */
456 HWTEST_F (BatterySttest, BatteryST011, TestSize.Level1)
457 {
458 HDF_LOGD("%{public}s: enter. BatteryST011 start.", __func__);
459 CreateFile("/data/local/tmp/battery/health", "Dead");
460
461 auto healthState = g_service->GetHealthStatus();
462 HDF_LOGD("%{public}s: enter. BatteryST011::healthState=%{public}d.", __func__, healthState);
463
464 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_DEAD);
465 HDF_LOGD("%{public}s: enter. BatteryST011 end.", __func__);
466 }
467
468 /**
469 * @tc.name: BatteryST012
470 * @tc.desc: Test functions of HDI Interface GetHealthState when state is "Unknown"
471 * @tc.type: FUNC
472 */
473 HWTEST_F (BatterySttest, BatteryST012, TestSize.Level1)
474 {
475 HDF_LOGD("%{public}s: enter. BatteryST012 start.", __func__);
476 CreateFile("/data/local/tmp/battery/health", "Unknown");
477
478 auto healthState = g_service->GetHealthStatus();
479 HDF_LOGD("%{public}s: enter. BatteryST012::healthState=%{public}d.", __func__, healthState);
480
481 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_UNKNOWN);
482 HDF_LOGD("%{public}s: enter. BatteryST012 end.", __func__);
483 }
484
485 /**
486 * @tc.name: BatteryST013
487 * @tc.desc: Test functions of HDI Interface GetHealthState when state is "Unspecified failure"
488 * @tc.type: FUNC
489 */
490 HWTEST_F (BatterySttest, BatteryST013, TestSize.Level1)
491 {
492 HDF_LOGD("%{public}s: enter. BatteryST013 start.", __func__);
493 CreateFile("/data/local/tmp/battery/health", "Unspecified failure");
494
495 auto healthState = g_service->GetHealthStatus();
496 HDF_LOGD("%{public}s: enter. BatteryST013::healthState=%{public}d.", __func__, healthState);
497
498 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_UNKNOWN);
499 HDF_LOGD("%{public}s: enter. BatteryST013 end.", __func__);
500 }
501
502 /**
503 * @tc.name: BatteryST014
504 * @tc.desc: Test functions of HDI Interface GetHealthState when state is "NULL"
505 * @tc.type: FUNC
506 */
507 HWTEST_F (BatterySttest, BatteryST014, TestSize.Level1)
508 {
509 HDF_LOGD("%{public}s: enter. BatteryST014 start.", __func__);
510 CreateFile("/data/local/tmp/battery/health", "");
511
512 auto healthState = g_service->GetHealthStatus();
513 HDF_LOGD("%{public}s: enter. BatteryST014::healthState=%{public}d.", __func__, healthState);
514
515 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_UNKNOWN);
516 HDF_LOGD("%{public}s: enter. BatteryST014 end.", __func__);
517 }
518
519 /**
520 * @tc.name: BatteryST015
521 * @tc.desc: Test functions of HDI Interface GetHealthState when state is not in healthStateEnumMap
522 * @tc.type: FUNC
523 */
524 HWTEST_F (BatterySttest, BatteryST015, TestSize.Level1)
525 {
526 HDF_LOGD("%{public}s: enter. BatteryST015 start.", __func__);
527 CreateFile("/data/local/tmp/battery/health", "other");
528
529 auto healthState = g_service->GetHealthStatus();
530 HDF_LOGD("%{public}s: enter. BatteryST015::healthState=%{public}d.", __func__, healthState);
531
532 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_UNKNOWN);
533 HDF_LOGD("%{public}s: enter. BatteryST015 end.", __func__);
534 }
535
536 /**
537 * @tc.name: BatteryST016
538 * @tc.desc: Test HDI interface GetPluggedType when pluggedtype is "USB"
539 * @tc.type: FUNC
540 */
541 HWTEST_F (BatterySttest, BatteryST016, TestSize.Level1)
542 {
543 HDF_LOGD("%{public}s: enter. BatteryST016 start.", __func__);
544 CreateFile("/data/local/tmp/ohos_charger/type", "USB");
545 CreateFile("/data/local/tmp/battery/type", "USB");
546 CreateFile("/data/local/tmp/ohos-fgu/type", "USB");
547 CreateFile("/data/local/tmp/ohos_charger/online", "1");
548 CreateFile("/data/local/tmp/battery/online", "1");
549 CreateFile("/data/local/tmp/ohos-fgu/online", "1");
550
551 std::string path = "/data/local/tmp";
552 g_service->ChangePath(path);
553 auto pluggedType = g_service->GetPluggedType();
554 HDF_LOGD("%{public}s: enter. BatteryST016::pluggedType=%{public}d.", __func__, pluggedType);
555
556 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_USB);
557 HDF_LOGD("%{public}s: enter. BatteryST016 end.", __func__);
558 }
559
560 /**
561 * @tc.name: BatteryST017
562 * @tc.desc: Test HDI interface GetPluggedType when pluggedtype is "USB_PD_DRP"
563 * @tc.type: FUNC
564 */
565 HWTEST_F (BatterySttest, BatteryST017, TestSize.Level1)
566 {
567 HDF_LOGD("%{public}s: enter. BatteryST017 start.", __func__);
568 CreateFile("/data/local/tmp/ohos_charger/type", "USB_PD_DRP");
569 CreateFile("/data/local/tmp/battery/type", "USB_PD_DRP");
570 CreateFile("/data/local/tmp/ohos-fgu/type", "USB_PD_DRP");
571
572 auto pluggedType = g_service->GetPluggedType();
573 HDF_LOGD("%{public}s: enter. BatteryST017::pluggedType=%{public}d.", __func__, pluggedType);
574
575 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_USB);
576 HDF_LOGD("%{public}s: enter. BatteryST017 end.", __func__);
577 }
578
579 /**
580 * @tc.name: BatteryST018
581 * @tc.desc: Test HDI interface GetPluggedType when pluggedtype is "Wireless"
582 * @tc.type: FUNC
583 */
584 HWTEST_F (BatterySttest, BatteryST018, TestSize.Level1)
585 {
586 HDF_LOGD("%{public}s: enter. BatteryST018 start.", __func__);
587 CreateFile("/data/local/tmp/ohos_charger/type", "Wireless");
588 CreateFile("/data/local/tmp/battery/type", "Wireless");
589 CreateFile("/data/local/tmp/ohos-fgu/type", "Wireless");
590
591 auto pluggedType = g_service->GetPluggedType();
592 HDF_LOGD("%{public}s: enter. BatteryST018::pluggedType=%{public}d.", __func__, pluggedType);
593
594 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_WIRELESS);
595 HDF_LOGD("%{public}s: enter. BatteryST018 end.", __func__);
596 }
597
598 /**
599 * @tc.name: BatteryST019
600 * @tc.desc: Test HDI interface GetPluggedType when pluggedtype is "Mains"
601 * @tc.type: FUNC
602 */
603 HWTEST_F (BatterySttest, BatteryST019, TestSize.Level1)
604 {
605 HDF_LOGD("%{public}s: enter. BatteryST019 start.", __func__);
606 CreateFile("/data/local/tmp/ohos_charger/type", "Mains");
607 CreateFile("/data/local/tmp/battery/type", "Mains");
608 CreateFile("/data/local/tmp/ohos-fgu/type", "Mains");
609
610 auto pluggedType = g_service->GetPluggedType();
611 HDF_LOGD("%{public}s: enter. BatteryST019::pluggedType=%{public}d.", __func__, pluggedType);
612
613 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_AC);
614 HDF_LOGD("%{public}s: enter. BatteryST019 end.", __func__);
615 }
616
617 /**
618 * @tc.name: BatteryST020
619 * @tc.desc: Test HDI interface GetPluggedType when pluggedtype is "UPS"
620 * @tc.type: FUNC
621 */
622 HWTEST_F (BatterySttest, BatteryST020, TestSize.Level1)
623 {
624 HDF_LOGD("%{public}s: enter. BatteryST020 start.", __func__);
625 CreateFile("/data/local/tmp/ohos_charger/type", "UPS");
626 CreateFile("/data/local/tmp/battery/type", "UPS");
627 CreateFile("/data/local/tmp/ohos-fgu/type", "UPS");
628
629 auto pluggedType = g_service->GetPluggedType();
630 HDF_LOGD("%{public}s: enter. BatteryST020::pluggedType=%{public}d.", __func__, pluggedType);
631
632 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_AC);
633 HDF_LOGD("%{public}s: enter. BatteryST020 end.", __func__);
634 }
635
636 /**
637 * @tc.name: BatteryST021
638 * @tc.desc: Test HDI interface GetPluggedType when pluggedtype is "USB_ACA"
639 * @tc.type: FUNC
640 */
641 HWTEST_F (BatterySttest, BatteryST021, TestSize.Level1)
642 {
643 HDF_LOGD("%{public}s: enter. BatteryST021 start.", __func__);
644 CreateFile("/data/local/tmp/ohos_charger/type", "USB_ACA");
645 CreateFile("/data/local/tmp/battery/type", "USB_ACA");
646 CreateFile("/data/local/tmp/ohos-fgu/type", "USB_ACA");
647
648 auto pluggedType = g_service->GetPluggedType();
649 HDF_LOGD("%{public}s: enter. BatteryST021::pluggedType=%{public}d.", __func__, pluggedType);
650
651 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_AC);
652 HDF_LOGD("%{public}s: enter. BatteryST021 end.", __func__);
653 }
654
655 /**
656 * @tc.name: BatteryST022
657 * @tc.desc: Test HDI interface GetPluggedType when pluggedtype is "USB_C"
658 * @tc.type: FUNC
659 */
660 HWTEST_F (BatterySttest, BatteryST022, TestSize.Level1)
661 {
662 HDF_LOGD("%{public}s: enter. BatteryST022 start.", __func__);
663 CreateFile("/data/local/tmp/ohos_charger/type", "USB_C");
664 CreateFile("/data/local/tmp/battery/type", "USB_C");
665 CreateFile("/data/local/tmp/ohos-fgu/type", "USB_C");
666
667 auto pluggedType = g_service->GetPluggedType();
668 HDF_LOGD("%{public}s: enter. BatteryST022::pluggedType=%{public}d.", __func__, pluggedType);
669
670 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_AC);
671 HDF_LOGD("%{public}s: enter. BatteryST022 end.", __func__);
672 }
673
674 /**
675 * @tc.name: BatteryST023
676 * @tc.desc: Test HDI interface GetPluggedType when pluggedtype is "USB_CDP"
677 * @tc.type: FUNC
678 */
679 HWTEST_F (BatterySttest, BatteryST023, TestSize.Level1)
680 {
681 HDF_LOGD("%{public}s: enter. BatteryST023 start.", __func__);
682 CreateFile("/data/local/tmp/ohos_charger/type", "USB_CDP");
683 CreateFile("/data/local/tmp/battery/type", "USB_CDP");
684 CreateFile("/data/local/tmp/ohos-fgu/type", "USB_CDP");
685
686 auto pluggedType = g_service->GetPluggedType();
687 HDF_LOGD("%{public}s: enter. BatteryST023::pluggedType=%{public}d.", __func__, pluggedType);
688
689 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_AC);
690 HDF_LOGD("%{public}s: enter. BatteryST023 end.", __func__);
691 }
692
693 /**
694 * @tc.name: BatteryST024
695 * @tc.desc: Test HDI interface GetPluggedType when pluggedtype is "USB_DCP"
696 * @tc.type: FUNC
697 */
698 HWTEST_F (BatterySttest, BatteryST024, TestSize.Level1)
699 {
700 HDF_LOGD("%{public}s: enter. BatteryST024 start.", __func__);
701 CreateFile("/data/local/tmp/ohos_charger/type", "USB_DCP");
702 CreateFile("/data/local/tmp/battery/type", "USB_DCP");
703 CreateFile("/data/local/tmp/ohos-fgu/type", "USB_DCP");
704
705 auto pluggedType = g_service->GetPluggedType();
706 HDF_LOGD("%{public}s: enter. BatteryST024::pluggedType=%{public}d.", __func__, pluggedType);
707
708 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_AC);
709 HDF_LOGD("%{public}s: enter. BatteryST024 end.", __func__);
710 }
711
712 /**
713 * @tc.name: BatteryST025
714 * @tc.desc: Test HDI interface GetPluggedType when pluggedtype is "USB_HVDCP"
715 * @tc.type: FUNC
716 */
717 HWTEST_F (BatterySttest, BatteryST025, TestSize.Level1)
718 {
719 HDF_LOGD("%{public}s: enter. BatteryST025 start.", __func__);
720 CreateFile("/data/local/tmp/ohos_charger/type", "USB_HVDCP");
721 CreateFile("/data/local/tmp/battery/type", "USB_HVDCP");
722 CreateFile("/data/local/tmp/ohos-fgu/type", "USB_HVDCP");
723
724 auto pluggedType = g_service->GetPluggedType();
725 HDF_LOGD("%{public}s: enter. BatteryST025::pluggedType=%{public}d.", __func__, pluggedType);
726
727 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_AC);
728 HDF_LOGD("%{public}s: enter. BatteryST025 end.", __func__);
729 }
730
731 /**
732 * @tc.name: BatteryST026
733 * @tc.desc: Test HDI interface GetPluggedType when pluggedtype is "USB_PD"
734 * @tc.type: FUNC
735 */
736 HWTEST_F (BatterySttest, BatteryST026, TestSize.Level1)
737 {
738 HDF_LOGD("%{public}s: enter. BatteryST026 start.", __func__);
739 CreateFile("/data/local/tmp/ohos_charger/type", "USB_PD");
740 CreateFile("/data/local/tmp/battery/type", "USB_PD");
741 CreateFile("/data/local/tmp/ohos-fgu/type", "USB_PD");
742
743 auto pluggedType = g_service->GetPluggedType();
744 HDF_LOGD("%{public}s: enter. BatteryST026::pluggedType=%{public}d.", __func__, pluggedType);
745
746 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_AC);
747 HDF_LOGD("%{public}s: enter. BatteryST026 end.", __func__);
748 }
749
750 /**
751 * @tc.name: BatteryST027
752 * @tc.desc: Test HDI interface GetPluggedType when pluggedtype is "Unknown"
753 * @tc.type: FUNC
754 */
755 HWTEST_F (BatterySttest, BatteryST027, TestSize.Level1)
756 {
757 HDF_LOGD("%{public}s: enter. BatteryST027 start.", __func__);
758 CreateFile("/data/local/tmp/ohos_charger/type", "Unknown");
759 CreateFile("/data/local/tmp/battery/type", "Unknown");
760 CreateFile("/data/local/tmp/ohos-fgu/type", "Unknown");
761
762 auto pluggedType = g_service->GetPluggedType();
763 HDF_LOGD("%{public}s: enter. BatteryST027::pluggedType=%{public}d.", __func__, pluggedType);
764
765 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_NONE);
766 HDF_LOGD("%{public}s: enter. BatteryST027 end.", __func__);
767 }
768
769 /**
770 * @tc.name: BatteryST028
771 * @tc.desc: Test HDI interface GetPluggedType when pluggedtype is NULL
772 * @tc.type: FUNC
773 */
774 HWTEST_F (BatterySttest, BatteryST028, TestSize.Level1)
775 {
776 HDF_LOGD("%{public}s: enter. BatteryST028 start.", __func__);
777 CreateFile("/data/local/tmp/ohos_charger/type", "");
778 CreateFile("/data/local/tmp/battery/type", "");
779 CreateFile("/data/local/tmp/ohos-fgu/type", "");
780
781 auto pluggedType = g_service->GetPluggedType();
782 HDF_LOGD("%{public}s: enter. BatteryST028::pluggedType=%{public}d.", __func__, pluggedType);
783
784 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_NONE);
785 HDF_LOGD("%{public}s: enter. BatteryST028 end.", __func__);
786 }
787
788 /**
789 * @tc.name: BatteryST029
790 * @tc.desc: Test HDI interface GetPluggedType when pluggedtype is not in pluggedTypeEnumMap
791 * @tc.type: FUNC
792 */
793 HWTEST_F (BatterySttest, BatteryST029, TestSize.Level1)
794 {
795 HDF_LOGD("%{public}s: enter. BatteryST029 start.", __func__);
796 CreateFile("/data/local/tmp/ohos_charger/type", "other");
797 CreateFile("/data/local/tmp/battery/type", "other");
798 CreateFile("/data/local/tmp/ohos-fgu/type", "other");
799
800 auto pluggedType = g_service->GetPluggedType();
801 HDF_LOGD("%{public}s: enter. BatteryST029::pluggedType=%{public}d.", __func__, pluggedType);
802
803 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_NONE);
804 HDF_LOGD("%{public}s: enter. BatteryST029 end.", __func__);
805 }
806
807 /**
808 * @tc.name: BatteryST030
809 * @tc.desc: Test HDI interface GetChargingStatus when state is "Discharging"
810 * @tc.type: FUNC
811 */
812 HWTEST_F (BatterySttest, BatteryST030, TestSize.Level1)
813 {
814 HDF_LOGD("%{public}s: enter. BatteryST030 start.", __func__);
815 CreateFile("/data/local/tmp/battery/status", "Discharging");
816
817 auto chargeState = g_service->GetChargingStatus();
818 HDF_LOGD("%{public}s: enter. BatteryST030::chargeState=%{public}d.", __func__, chargeState);
819
820 ASSERT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_NONE);
821 HDF_LOGD("%{public}s: enter. BatteryST030 end.", __func__);
822 }
823
824 /**
825 * @tc.name: BatteryST031
826 * @tc.desc: Test HDI interface GetChargingStatus when state is "Charging"
827 * @tc.type: FUNC
828 */
829 HWTEST_F (BatterySttest, BatteryST031, TestSize.Level1)
830 {
831 HDF_LOGD("%{public}s: enter. BatteryST031 start.", __func__);
832 CreateFile("/data/local/tmp/battery/status", "Charging");
833
834 auto chargeState = g_service->GetChargingStatus();
835 HDF_LOGD("%{public}s: enter. BatteryST031::chargeState=%{public}d.", __func__, chargeState);
836
837 ASSERT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_ENABLE);
838 HDF_LOGD("%{public}s: enter. BatteryST031 end.", __func__);
839 }
840
841 /**
842 * @tc.name: BatteryST032
843 * @tc.desc: Test HDI interface GetChargingStatus when state is "Full"
844 * @tc.type: FUNC
845 */
846 HWTEST_F (BatterySttest, BatteryST032, TestSize.Level1)
847 {
848 HDF_LOGD("%{public}s: enter. BatteryST032 start.", __func__);
849 CreateFile("/data/local/tmp/battery/status", "Full");
850
851 auto chargeState = g_service->GetChargingStatus();
852 HDF_LOGD("%{public}s: enter. BatteryST032::chargeState=%{public}d.", __func__, chargeState);
853
854 ASSERT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_FULL);
855 HDF_LOGD("%{public}s: enter. BatteryST032 end.", __func__);
856 }
857
858 /**
859 * @tc.name: BatteryST033
860 * @tc.desc: Test HDI interface GetChargingStatus when state is "Not charging"
861 * @tc.type: FUNC
862 */
863 HWTEST_F (BatterySttest, BatteryST033, TestSize.Level1)
864 {
865 HDF_LOGD("%{public}s: enter. BatteryST033 start.", __func__);
866 CreateFile("/data/local/tmp/battery/status", "Not charging");
867
868 auto chargeState = g_service->GetChargingStatus();
869 HDF_LOGD("%{public}s: enter. BatteryST033::chargeState=%{public}d.", __func__, chargeState);
870
871 ASSERT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_DISABLE);
872 HDF_LOGD("%{public}s: enter. BatteryST033 end.", __func__);
873 }
874
875 /**
876 * @tc.name: BatteryST034
877 * @tc.desc: Test HDI interface GetChargingStatus when state is "Unknown"
878 * @tc.type: FUNC
879 */
880 HWTEST_F (BatterySttest, BatteryST034, TestSize.Level1)
881 {
882 HDF_LOGD("%{public}s: enter. BatteryST034 start.", __func__);
883 CreateFile("/data/local/tmp/battery/status", "Unknown");
884
885 auto chargeState = g_service->GetChargingStatus();
886 HDF_LOGD("%{public}s: enter. BatteryST034::chargeState=%{public}d.", __func__, chargeState);
887
888 ASSERT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_BUTT);
889 HDF_LOGD("%{public}s: enter. BatteryST034 end.", __func__);
890 }
891
892 /**
893 * @tc.name: BatteryST035
894 * @tc.desc: Test HDI interface GetChargingStatus when state is NULL
895 * @tc.type: FUNC
896 */
897 HWTEST_F (BatterySttest, BatteryST035, TestSize.Level1)
898 {
899 HDF_LOGD("%{public}s: enter. BatteryST035 start.", __func__);
900 CreateFile("/data/local/tmp/battery/status", "");
901
902 auto chargeState = g_service->GetChargingStatus();
903 HDF_LOGD("%{public}s: enter. BatteryST035::chargeState=%{public}d.", __func__, chargeState);
904
905 ASSERT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_BUTT);
906 HDF_LOGD("%{public}s: enter. BatteryST035 end.", __func__);
907 }
908
909 /**
910 * @tc.name: BatteryST036
911 * @tc.desc: Test HDI interface GetChargingStatus when state is not in chargeStateEnumMap
912 * @tc.type: FUNC
913 */
914 HWTEST_F (BatterySttest, BatteryST036, TestSize.Level1)
915 {
916 HDF_LOGD("%{public}s: enter. BatteryST036 start.", __func__);
917 CreateFile("/data/local/tmp/battery/status", "others");
918
919 auto chargeState = g_service->GetChargingStatus();
920 HDF_LOGD("%{public}s: enter. BatteryST036::chargeState=%{public}d.", __func__, chargeState);
921
922 ASSERT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_BUTT);
923 HDF_LOGD("%{public}s: enter. BatteryST036 end.", __func__);
924 }
925
926 /**
927 * @tc.name: BatteryST037
928 * @tc.desc: Test functions of HDI Interface GetPresent when battery is exist
929 * @tc.type: FUNC
930 */
931 HWTEST_F (BatterySttest, BatteryST037, TestSize.Level1)
932 {
933 HDF_LOGD("%{public}s: enter. BatteryST037 start.", __func__);
934 CreateFile("/data/local/tmp/battery/present", "1");
935
936 auto present = g_service->GetPresent();
937 HDF_LOGD("%{public}s: enter. BatteryST037::present=%{public}d.", __func__, present);
938
939 ASSERT_TRUE(present);
940 HDF_LOGD("%{public}s: enter. BatteryST037 end.", __func__);
941 }
942
943 /**
944 * @tc.name: BatteryST038
945 * @tc.desc: Test functions of HDI Interface GetPresent when battery is not exist
946 * @tc.type: FUNC
947 */
948 HWTEST_F (BatterySttest, BatteryST038, TestSize.Level1)
949 {
950 HDF_LOGD("%{public}s: enter. BatteryST038 start.", __func__);
951 CreateFile("/data/local/tmp/battery/present", "0");
952
953 auto present = g_service->GetPresent();
954 HDF_LOGD("%{public}s: enter. BatteryST038::present=%{public}d.", __func__, present);
955
956 ASSERT_TRUE(!present);
957 HDF_LOGD("%{public}s: enter. BatteryST038 end.", __func__);
958 }
959
960 /**
961 * @tc.name: BatteryST039
962 * @tc.desc: Test functions of HDI Interface GetTechnology
963 * @tc.type: FUNC
964 */
965 HWTEST_F (BatterySttest, BatteryST039, TestSize.Level1)
966 {
967 HDF_LOGD("%{public}s: enter. BatteryST039 start.", __func__);
968 CreateFile("/data/local/tmp/ohos-fgu/technology", "Li");
969
970 auto technology = g_service->GetTechnology();
971 HDF_LOGD("%{public}s: enter. BatteryST039::technology=%{public}s.", __func__, technology.c_str());
972
973 ASSERT_TRUE(technology == "Li");
974 HDF_LOGD("%{public}s: enter. BatteryST039 end.", __func__);
975 }
976
977 /**
978 * @tc.name: BatteryST042
979 * @tc.desc: Test IBatterySrv interface GetCapacity
980 * @tc.type: FUNC
981 */
982 HWTEST_F (BatterySttest, BatteryST042, TestSize.Level1)
983 {
984 HDF_LOGD("%{public}s: enter. BatteryST042 start.", __func__);
985 CreateFile("/data/local/tmp/battery/capacity", "44");
986
987 auto& BatterySrvClient = BatterySrvClient::GetInstance();
988 auto capacity = BatterySrvClient.GetCapacity();
989 HDF_LOGD("%{public}s: enter. BatteryST042::capacity=%{public}d.", __func__, capacity);
990 GTEST_LOG_(INFO) << "BatteryST042 executing, capacity=" << capacity;
991
992 ASSERT_TRUE(capacity == 44);
993 HDF_LOGD("%{public}s: enter. BatteryST042 end.", __func__);
994 }
995
996 /**
997 * @tc.name: BatteryST043
998 * @tc.desc: Test IBatterySrv interface GetChargingStatus when chargestate value is none
999 * @tc.type: FUNC
1000 */
1001 HWTEST_F (BatterySttest, BatteryST043, TestSize.Level1)
1002 {
1003 HDF_LOGD("%{public}s: enter. BatteryST043 start.", __func__);
1004 CreateFile("/data/local/tmp/battery/status", "Discharging");
1005
1006 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1007 auto chargeState = BatterySrvClient.GetChargingStatus();
1008 GTEST_LOG_(INFO) << "BatteryST043 executing, chargeState=" << int(chargeState);
1009
1010 ASSERT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_NONE);
1011 HDF_LOGD("%{public}s: enter. BatteryST043 end.", __func__);
1012 }
1013
1014 /**
1015 * @tc.name: BatteryST044
1016 * @tc.desc: Test IBatterySrv interface GetChargingStatus when chargestate value is enable
1017 * @tc.type: FUNC
1018 */
1019 HWTEST_F (BatterySttest, BatteryST044, TestSize.Level1)
1020 {
1021 HDF_LOGD("%{public}s: enter. BatteryST044 start.", __func__);
1022 CreateFile("/data/local/tmp/battery/status", "Charging");
1023
1024 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1025 auto chargeState = BatterySrvClient.GetChargingStatus();
1026 GTEST_LOG_(INFO) << "BatteryST044 executing, chargeState=" << int(chargeState);
1027
1028 ASSERT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_ENABLE);
1029 HDF_LOGD("%{public}s: enter. BatteryST044 end.", __func__);
1030 }
1031
1032 /**
1033 * @tc.name: BatteryST045
1034 * @tc.desc: Test IBatterySrv interface GetChargingStatus when chargestate value is full
1035 * @tc.type: FUNC
1036 */
1037 HWTEST_F (BatterySttest, BatteryST045, TestSize.Level1)
1038 {
1039 HDF_LOGD("%{public}s: enter. BatteryST045 start.", __func__);
1040 CreateFile("/data/local/tmp/battery/status", "Full");
1041
1042 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1043 auto chargeState = BatterySrvClient.GetChargingStatus();
1044 GTEST_LOG_(INFO) << "BatteryST045 executing, chargeState=" << int(chargeState);
1045
1046 ASSERT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_FULL);
1047 HDF_LOGD("%{public}s: enter. BatteryST045 end.", __func__);
1048 }
1049
1050 /**
1051 * @tc.name: BatteryST046
1052 * @tc.desc: Test IBatterySrv interface GetChargingStatus when chargestate value is disable
1053 * @tc.type: FUNC
1054 */
1055 HWTEST_F (BatterySttest, BatteryST046, TestSize.Level1)
1056 {
1057 HDF_LOGD("%{public}s: enter. BatteryST046 start.", __func__);
1058 CreateFile("/data/local/tmp/battery/status", "Not charging");
1059
1060 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1061 auto chargeState = BatterySrvClient.GetChargingStatus();
1062 GTEST_LOG_(INFO) << "BatteryST046 executing, chargeState=" << int(chargeState);
1063
1064 ASSERT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_DISABLE);
1065 HDF_LOGD("%{public}s: enter. BatteryST046 end.", __func__);
1066 }
1067
1068 /**
1069 * @tc.name: BatteryST047
1070 * @tc.desc: Test IBatterySrv interface GetChargingStatus when chargestate value is butt
1071 * @tc.type: FUNC
1072 */
1073 HWTEST_F (BatterySttest, BatteryST047, TestSize.Level1)
1074 {
1075 HDF_LOGD("%{public}s: enter. BatteryST047 start.", __func__);
1076 CreateFile("/data/local/tmp/battery/status", "Unknown");
1077
1078 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1079 auto chargeState = BatterySrvClient.GetChargingStatus();
1080 GTEST_LOG_(INFO) << "BatteryST047 executing, chargeState=" << int(chargeState);
1081
1082 ASSERT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_BUTT);
1083 HDF_LOGD("%{public}s: enter. BatteryST047 end.", __func__);
1084 }
1085
1086 /**
1087 * @tc.name: BatteryST048
1088 * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_GOOD
1089 * @tc.type: FUNC
1090 */
1091 HWTEST_F (BatterySttest, BatteryST048, TestSize.Level1)
1092 {
1093 HDF_LOGD("%{public}s: enter. BatteryST048 start.", __func__);
1094 CreateFile("/data/local/tmp/battery/health", "Good");
1095
1096 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1097 auto healthState = BatterySrvClient.GetHealthStatus();
1098 GTEST_LOG_(INFO) << "BatteryST048 executing, healthState=" << int(healthState);
1099
1100 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
1101 HDF_LOGD("%{public}s: enter. BatteryST048 end.", __func__);
1102 }
1103
1104 /**
1105 * @tc.name: BatteryST049
1106 * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_COLD
1107 * @tc.type: FUNC
1108 */
1109 HWTEST_F (BatterySttest, BatteryST049, TestSize.Level1)
1110 {
1111 HDF_LOGD("%{public}s: enter. BatteryST049 start.", __func__);
1112 CreateFile("/data/local/tmp/battery/health", "Cold");
1113
1114 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1115 auto healthState = BatterySrvClient.GetHealthStatus();
1116 GTEST_LOG_(INFO) << "BatteryST049 executing, healthState=" << int(healthState);
1117
1118 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_COLD);
1119 HDF_LOGD("%{public}s: enter. BatteryST049 end.", __func__);
1120 }
1121
1122 /**
1123 * @tc.name: BatteryST050
1124 * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_OVERHEAT
1125 * @tc.type: FUNC
1126 */
1127 HWTEST_F (BatterySttest, BatteryST050, TestSize.Level1)
1128 {
1129 HDF_LOGD("%{public}s: enter. BatteryST050 start.", __func__);
1130 CreateFile("/data/local/tmp/battery/health", "Hot");
1131
1132 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1133 auto healthState = BatterySrvClient.GetHealthStatus();
1134 GTEST_LOG_(INFO) << "BatteryST050 executing, healthState=" << int(healthState);
1135
1136 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_OVERHEAT);
1137 HDF_LOGD("%{public}s: enter. BatteryST050 end.", __func__);
1138 }
1139
1140 /**
1141 * @tc.name: BatteryST051
1142 * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_OVERVOLTAGE
1143 * @tc.type: FUNC
1144 */
1145 HWTEST_F (BatterySttest, BatteryST051, TestSize.Level1)
1146 {
1147 HDF_LOGD("%{public}s: enter. BatteryST051 start.", __func__);
1148 CreateFile("/data/local/tmp/battery/health", "Over voltage");
1149
1150 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1151 auto healthState = BatterySrvClient.GetHealthStatus();
1152 GTEST_LOG_(INFO) << "BatteryST051 executing, healthState=" << int(healthState);
1153
1154 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_OVERVOLTAGE);
1155 HDF_LOGD("%{public}s: enter. BatteryST051 end.", __func__);
1156 }
1157
1158 /**
1159 * @tc.name: BatteryST052
1160 * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_DEAD
1161 * @tc.type: FUNC
1162 */
1163 HWTEST_F (BatterySttest, BatteryST052, TestSize.Level1)
1164 {
1165 HDF_LOGD("%{public}s: enter. BatteryST052 start.", __func__);
1166 CreateFile("/data/local/tmp/battery/health", "Dead");
1167
1168 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1169 auto healthState = BatterySrvClient.GetHealthStatus();
1170 GTEST_LOG_(INFO) << "BatteryST052 executing, healthState=" << int(healthState);
1171
1172 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_DEAD);
1173 HDF_LOGD("%{public}s: enter. BatteryST052 end.", __func__);
1174 }
1175
1176 /**
1177 * @tc.name: BatteryST053
1178 * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_UNKNOWN
1179 * @tc.type: FUNC
1180 */
1181 HWTEST_F (BatterySttest, BatteryST053, TestSize.Level1)
1182 {
1183 HDF_LOGD("%{public}s: enter. BatteryST053 start.", __func__);
1184 CreateFile("/data/local/tmp/battery/health", "Unknown");
1185
1186 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1187 auto healthState = BatterySrvClient.GetHealthStatus();
1188 GTEST_LOG_(INFO) << "BatteryST053 executing, healthState=" << int(healthState);
1189
1190 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_UNKNOWN);
1191 HDF_LOGD("%{public}s: enter. BatteryST053 end.", __func__);
1192 }
1193
1194 /**
1195 * @tc.name: BatteryST054
1196 * @tc.desc: Test IBatterySrv interface GetPresent when present is true
1197 * @tc.type: FUNC
1198 */
1199 HWTEST_F (BatterySttest, BatteryST054, TestSize.Level1)
1200 {
1201 HDF_LOGD("%{public}s: enter. BatteryST054 start.", __func__);
1202 CreateFile("/data/local/tmp/battery/present", "1");
1203
1204 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1205 auto present = BatterySrvClient.GetPresent();
1206 GTEST_LOG_(INFO) << "BatteryST054 executing, present=" << present;
1207
1208 ASSERT_TRUE(present);
1209 HDF_LOGD("%{public}s: enter. BatteryST054 end.", __func__);
1210 }
1211
1212 /**
1213 * @tc.name: BatteryST055
1214 * @tc.desc: Test IBatterySrv interface GetPresent when present is false
1215 * @tc.type: FUNC
1216 */
1217 HWTEST_F (BatterySttest, BatteryST055, TestSize.Level1)
1218 {
1219 HDF_LOGD("%{public}s: enter. BatteryST055 start.", __func__);
1220 CreateFile("/data/local/tmp/battery/present", "0");
1221
1222 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1223 auto present = BatterySrvClient.GetPresent();
1224 GTEST_LOG_(INFO) << "BatteryST055 executing, present=" << present;
1225
1226 ASSERT_FALSE(present);
1227 HDF_LOGD("%{public}s: enter. BatteryST055 end.", __func__);
1228 }
1229
1230 /**
1231 * @tc.name: BatteryST056
1232 * @tc.desc: Test IBatterySrv interface GetVoltage
1233 * @tc.type: FUNC
1234 */
1235 HWTEST_F (BatterySttest, BatteryST056, TestSize.Level1)
1236 {
1237 HDF_LOGD("%{public}s: enter. BatteryST056 start.", __func__);
1238 CreateFile("/data/local/tmp/battery/voltage_avg", "4654321");
1239 CreateFile("/data/local/tmp/battery/voltage_now", "4654321");
1240
1241 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1242 auto voltage = BatterySrvClient.GetVoltage();
1243 GTEST_LOG_(INFO) << "BatteryST056 executing, voltage=" << voltage;
1244
1245 ASSERT_TRUE(voltage == 4654321);
1246 HDF_LOGD("%{public}s: enter. BatteryST056 end.", __func__);
1247 }
1248
1249 /**
1250 * @tc.name: BatteryST057
1251 * @tc.desc: Test IBatterySrv interface GetTemperature
1252 * @tc.type: FUNC
1253 */
1254 HWTEST_F (BatterySttest, BatteryST057, TestSize.Level1)
1255 {
1256 HDF_LOGD("%{public}s: enter. BatteryST057 start.", __func__);
1257 CreateFile("/data/local/tmp/battery/temp", "234");
1258
1259 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1260 auto temperature = BatterySrvClient.GetBatteryTemperature();
1261 GTEST_LOG_(INFO) << "BatteryST057 executing, temperature=" << temperature;
1262
1263 ASSERT_TRUE(temperature == 234);
1264 HDF_LOGD("%{public}s: enter. BatteryST057 end.", __func__);
1265 }
1266
1267 /**
1268 * @tc.name: BatteryST058
1269 * @tc.desc: Test IBatterySrv interface GetTechnology
1270 * @tc.type: FUNC
1271 */
1272 HWTEST_F (BatterySttest, BatteryST058, TestSize.Level1)
1273 {
1274 HDF_LOGD("%{public}s: enter. BatteryST058 start.", __func__);
1275 CreateFile("/data/local/tmp/ohos-fgu/technology", "H2");
1276
1277 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1278 auto technology = BatterySrvClient.GetTechnology();
1279
1280 ASSERT_TRUE(technology == "H2");
1281 HDF_LOGD("%{public}s: enter. BatteryST058 end.", __func__);
1282 }
1283
1284 /**
1285 * @tc.name: BatteryST059
1286 * @tc.desc: Test IBatterySrv interface GetPluggedType when pluggedType value is PLUGGED_TYPE_NONE
1287 * ParsePluggedType return HDF_ERR_NOT_SUPPORT, g_service->GetPluggedType FAIL
1288 * @tc.type: FUNC
1289 */
1290 HWTEST_F (BatterySttest, BatteryST059, TestSize.Level1)
1291 {
1292 HDF_LOGD("%{public}s: enter. BatteryST059 start.", __func__);
1293 CreateFile("/data/local/tmp/ohos_charger/type", "None");
1294 CreateFile("/data/local/tmp/ohos-fgu/type", "None");
1295
1296 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1297 auto pluggedType = BatterySrvClient.GetPluggedType();
1298 GTEST_LOG_(INFO) << "BatteryST059 executing, pluggedType=" << int(pluggedType);
1299
1300 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_NONE);
1301 HDF_LOGD("%{public}s: enter. BatteryST059 end.", __func__);
1302 }
1303
1304 /**
1305 * @tc.name: BatteryST060
1306 * @tc.desc: Test IBatterySrv interface GetPluggedType when pluggedType value is PLUGGED_TYPE_AC
1307 * @tc.type: FUNC
1308 */
1309 HWTEST_F (BatterySttest, BatteryST060, TestSize.Level1)
1310 {
1311 HDF_LOGD("%{public}s: enter. BatteryST060 start.", __func__);
1312 CreateFile("/data/local/tmp/ohos_charger/type", "Mains");
1313 CreateFile("/data/local/tmp/battery/type", "Mains");
1314 CreateFile("/data/local/tmp/ohos-fgu/type", "Mains");
1315
1316 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1317 auto pluggedType = BatterySrvClient.GetPluggedType();
1318 GTEST_LOG_(INFO) << "BatteryST060 executing, pluggedType=" << int(pluggedType);
1319
1320 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_AC);
1321 HDF_LOGD("%{public}s: enter. BatteryST060 end.", __func__);
1322 }
1323
1324 /**
1325 * @tc.name: BatteryST061
1326 * @tc.desc: Test IBatterySrv interface GetPluggedType when pluggedType value is PLUGGED_TYPE_USB
1327 * @tc.type: FUNC
1328 */
1329 HWTEST_F (BatterySttest, BatteryST061, TestSize.Level1)
1330 {
1331 HDF_LOGD("%{public}s: enter. BatteryST061 start.", __func__);
1332 CreateFile("/data/local/tmp/ohos_charger/type", "USB");
1333 CreateFile("/data/local/tmp/battery/type", "USB");
1334 CreateFile("/data/local/tmp/ohos-fgu/type", "USB");
1335
1336 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1337 auto pluggedType = BatterySrvClient.GetPluggedType();
1338 GTEST_LOG_(INFO) << "BatteryST061 executing, pluggedType=" << int(pluggedType);
1339
1340 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_USB);
1341 HDF_LOGD("%{public}s: enter. BatteryST061 end.", __func__);
1342 }
1343
1344 /**
1345 * @tc.name: BatteryST062
1346 * @tc.desc: Test IBatterySrv interface GetPluggedType when pluggedType value is PLUGGED_TYPE_WIRELESS
1347 * @tc.type: FUNC
1348 */
1349 HWTEST_F (BatterySttest, BatteryST062, TestSize.Level1)
1350 {
1351 HDF_LOGD("%{public}s: enter. BatteryST062 start.", __func__);
1352 CreateFile("/data/local/tmp/ohos_charger/type", "Wireless");
1353 CreateFile("/data/local/tmp/battery/type", "Wireless");
1354 CreateFile("/data/local/tmp/ohos-fgu/type", "Wireless");
1355
1356 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1357 auto pluggedType = BatterySrvClient.GetPluggedType();
1358 GTEST_LOG_(INFO) << "BatteryST062 executing, pluggedType=" << int(pluggedType);
1359
1360 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_WIRELESS);
1361 HDF_LOGD("%{public}s: enter. BatteryST062 end.", __func__);
1362 }
1363
1364 /**
1365 * @tc.name: BatteryST063
1366 * @tc.desc: Test IBatterySrv interface GetPluggedType when pluggedType value is PLUGGED_TYPE_BUTT
1367 * ParsePluggedType return HDF_ERR_NOT_SUPPORT, g_service->GetPluggedType FAIL
1368 * @tc.type: FUNC
1369 */
1370 HWTEST_F (BatterySttest, BatteryST063, TestSize.Level1)
1371 {
1372 HDF_LOGD("%{public}s: enter. BatteryST063 start.", __func__);
1373 CreateFile("/data/local/tmp/ohos_charger/type", "Unknown");
1374 CreateFile("/data/local/tmp/battery/type", "Unknown");
1375 CreateFile("/data/local/tmp/ohos-fgu/type", "Unknown");
1376
1377 auto& BatterySrvClient = BatterySrvClient::GetInstance();
1378 auto pluggedType = BatterySrvClient.GetPluggedType();
1379 GTEST_LOG_(INFO) << "BatteryST063 executing, pluggedType=" << int(pluggedType);
1380
1381 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_NONE);
1382 HDF_LOGD("%{public}s: enter. BatteryST063 end.", __func__);
1383 }
1384
1385 /**
1386 * @tc.name: BatteryST064
1387 * @tc.desc: Test Led color is red when capacity is 0
1388 * @tc.type: FUNC
1389 */
1390 HWTEST_F (BatterySttest, BatteryST064, TestSize.Level1)
1391 {
1392 HDF_LOGD("%{public}s: enter. BatteryST064 start.", __func__);
1393 InitLedsSysfs();
1394
1395 int32_t chargestate = PowerSupplyProvider::CHARGE_STATE_ENABLE;
1396 int32_t capacity = 0;
1397 BatteryLed batteryled;
1398 batteryled.InitLedsSysfs();
1399 UpdateLedColorTest(chargestate, capacity, batteryled);
1400
1401 int32_t value = ReadRedLedSysfs();
1402 GTEST_LOG_(INFO) << "BatteryST064 executing, red brightness value=" << value;
1403 ASSERT_TRUE(value == 255);
1404
1405 value = ReadGreenLedSysfs();
1406 GTEST_LOG_(INFO) << "BatteryST064 executing, green brightness value=" << value;
1407 ASSERT_TRUE(value == 0);
1408
1409 value = ReadBlueLedSysfs();
1410 GTEST_LOG_(INFO) << "BatteryST064 executing, blue brightness value=" << value;
1411
1412 ASSERT_TRUE(value == 0);
1413 HDF_LOGD("%{public}s: enter. BatteryST064 end.", __func__);
1414 }
1415
1416 /**
1417 * @tc.name: BatteryST065
1418 * @tc.desc: Test Led color is red when capacity range in (0,10), medium value
1419 * @tc.type: FUNC
1420 */
1421 HWTEST_F (BatterySttest, BatteryST065, TestSize.Level1)
1422 {
1423 HDF_LOGD("%{public}s: enter. BatteryST065 start.", __func__);
1424
1425 int32_t chargestate = PowerSupplyProvider::CHARGE_STATE_ENABLE;
1426 int32_t capacity = 5;
1427 BatteryLed batteryled;
1428 UpdateLedColorTest(chargestate, capacity, batteryled);
1429
1430 int32_t value = ReadRedLedSysfs();
1431 GTEST_LOG_(INFO) << "BatteryST065 executing, red brightness value=" << value;
1432 ASSERT_TRUE(value == 255);
1433
1434 value = ReadGreenLedSysfs();
1435 GTEST_LOG_(INFO) << "BatteryST065 executing, green brightness value=" << value;
1436 ASSERT_TRUE(value == 0);
1437
1438 value = ReadBlueLedSysfs();
1439 GTEST_LOG_(INFO) << "BatteryST065 executing, blue brightness value=" << value;
1440
1441 ASSERT_TRUE(value == 0);
1442 HDF_LOGD("%{public}s: enter. BatteryST065 end.", __func__);
1443 }
1444
1445 /**
1446 * @tc.name: BatteryST066
1447 * @tc.desc: Test Led color is red when capacity range in (0,10), critical value
1448 * @tc.type: FUNC
1449 */
1450 HWTEST_F (BatterySttest, BatteryST066, TestSize.Level1)
1451 {
1452 HDF_LOGD("%{public}s: enter. BatteryST066 start.", __func__);
1453
1454 int32_t chargestate = PowerSupplyProvider::CHARGE_STATE_ENABLE;
1455 int32_t capacity = 9;
1456 BatteryLed batteryled;
1457 UpdateLedColorTest(chargestate, capacity, batteryled);
1458
1459 int32_t value = ReadRedLedSysfs();
1460 GTEST_LOG_(INFO) << "BatteryST066 executing, red brightness value=" << value;
1461 ASSERT_TRUE(value == 255);
1462
1463 value = ReadGreenLedSysfs();
1464 GTEST_LOG_(INFO) << "BatteryST066 executing, green brightness value=" << value;
1465 ASSERT_TRUE(value == 0);
1466
1467 value = ReadBlueLedSysfs();
1468 GTEST_LOG_(INFO) << "BatteryST066 executing, blue brightness value=" << value;
1469
1470 ASSERT_TRUE(value == 0);
1471 HDF_LOGD("%{public}s: enter. BatteryST066 end.", __func__);
1472 }
1473
1474 /**
1475 * @tc.name: BatteryST067
1476 * @tc.desc: Test Led color is yellow when capacity is 10
1477 * @tc.type: FUNC
1478 */
1479 HWTEST_F (BatterySttest, BatteryST067, TestSize.Level1)
1480 {
1481 HDF_LOGD("%{public}s: enter. BatteryST067 start.", __func__);
1482
1483 int32_t chargestate = PowerSupplyProvider::CHARGE_STATE_ENABLE;
1484 int32_t capacity = 10;
1485 BatteryLed batteryled;
1486 UpdateLedColorTest(chargestate, capacity, batteryled);
1487
1488 int32_t value = ReadRedLedSysfs();
1489 GTEST_LOG_(INFO) << "BatteryST067 executing, red brightness value=" << value;
1490 ASSERT_TRUE(value == 255);
1491
1492 value = ReadGreenLedSysfs();
1493 GTEST_LOG_(INFO) << "BatteryST067 executing, green brightness value=" << value;
1494 ASSERT_TRUE(value == 255);
1495
1496 value = ReadBlueLedSysfs();
1497 GTEST_LOG_(INFO) << "BatteryST067 executing, blue brightness value=" << value;
1498
1499 ASSERT_TRUE(value == 0);
1500 HDF_LOGD("%{public}s: enter. BatteryST067 end.", __func__);
1501 }
1502
1503 /**
1504 * @tc.name: BatteryST068
1505 * @tc.desc: Test Led color is yellow when capacity is bigger than 10
1506 * @tc.type: FUNC
1507 */
1508 HWTEST_F (BatterySttest, BatteryST068, TestSize.Level1)
1509 {
1510 HDF_LOGD("%{public}s: enter. BatteryST068 start.", __func__);
1511
1512 int32_t chargestate = PowerSupplyProvider::CHARGE_STATE_ENABLE;
1513 int32_t capacity = 50;
1514 BatteryLed batteryled;
1515 UpdateLedColorTest(chargestate, capacity, batteryled);
1516
1517 int32_t value = ReadRedLedSysfs();
1518 GTEST_LOG_(INFO) << "BatteryST068 executing, red brightness value=" << value;
1519 ASSERT_TRUE(value == 255);
1520
1521 value = ReadGreenLedSysfs();
1522 GTEST_LOG_(INFO) << "BatteryST068 executing, green brightness value=" << value;
1523 ASSERT_TRUE(value == 255);
1524
1525 value = ReadBlueLedSysfs();
1526 GTEST_LOG_(INFO) << "BatteryST068 executing, blue brightness value=" << value;
1527
1528 ASSERT_TRUE(value == 0);
1529 HDF_LOGD("%{public}s: enter. BatteryST068 end.", __func__);
1530 }
1531
1532 /**
1533 * @tc.name: BatteryST069
1534 * @tc.desc: Test Led color is red when capacity range in [10,90), critical value
1535 * @tc.type: FUNC
1536 */
1537 HWTEST_F (BatterySttest, BatteryST069, TestSize.Level1)
1538 {
1539 HDF_LOGD("%{public}s: enter. BatteryST069 start.", __func__);
1540
1541 int32_t chargestate = PowerSupplyProvider::CHARGE_STATE_ENABLE;
1542 int32_t capacity = 89;
1543 BatteryLed batteryled;
1544 UpdateLedColorTest(chargestate, capacity, batteryled);
1545
1546 int32_t value = ReadRedLedSysfs();
1547 GTEST_LOG_(INFO) << "BatteryST069 executing, red brightness value=" << value;
1548 ASSERT_TRUE(value == 255);
1549
1550 value = ReadGreenLedSysfs();
1551 GTEST_LOG_(INFO) << "BatteryST069 executing, green brightness value=" << value;
1552 ASSERT_TRUE(value == 255);
1553
1554 value = ReadBlueLedSysfs();
1555 GTEST_LOG_(INFO) << "BatteryST069 executing, blue brightness value=" << value;
1556
1557 ASSERT_TRUE(value == 0);
1558 HDF_LOGD("%{public}s: enter. BatteryST069 end.", __func__);
1559 }
1560
1561 /**
1562 * @tc.name: BatteryST070
1563 * @tc.desc: Test Led color is yellow when capacity is 90
1564 * @tc.type: FUNC
1565 */
1566 HWTEST_F (BatterySttest, BatteryST070, TestSize.Level1)
1567 {
1568 HDF_LOGD("%{public}s: enter. BatteryST070 start.", __func__);
1569
1570 int32_t chargestate = PowerSupplyProvider::CHARGE_STATE_ENABLE;
1571 int32_t capacity = 90;
1572 BatteryLed batteryled;
1573 UpdateLedColorTest(chargestate, capacity, batteryled);
1574
1575 int32_t value = ReadRedLedSysfs();
1576 GTEST_LOG_(INFO) << "BatteryST070 executing, red brightness value=" << value;
1577 ASSERT_TRUE(value == 0);
1578
1579 value = ReadGreenLedSysfs();
1580 GTEST_LOG_(INFO) << "BatteryST070 executing, green brightness value=" << value;
1581 ASSERT_TRUE(value == 255);
1582
1583 value = ReadBlueLedSysfs();
1584 GTEST_LOG_(INFO) << "BatteryST070 executing, blue brightness value=" << value;
1585
1586 ASSERT_TRUE(value == 0);
1587 HDF_LOGD("%{public}s: enter. BatteryST070 end.", __func__);
1588 }
1589
1590 /**
1591 * @tc.name: BatteryST071
1592 * @tc.desc: Test Led color is yellow when capacity is bigger than 90
1593 * @tc.type: FUNC
1594 */
1595 HWTEST_F (BatterySttest, BatteryST071, TestSize.Level1)
1596 {
1597 HDF_LOGD("%{public}s: enter. BatteryST071 start.", __func__);
1598
1599 int32_t chargestate = PowerSupplyProvider::CHARGE_STATE_ENABLE;
1600 int32_t capacity = 95;
1601 BatteryLed batteryled;
1602 UpdateLedColorTest(chargestate, capacity, batteryled);
1603
1604 int32_t value = ReadRedLedSysfs();
1605 GTEST_LOG_(INFO) << "BatteryST071 executing, red brightness value=" << value;
1606 ASSERT_TRUE(value == 0);
1607
1608 value = ReadGreenLedSysfs();
1609 GTEST_LOG_(INFO) << "BatteryST071 executing, green brightness value=" << value;
1610 ASSERT_TRUE(value == 255);
1611
1612 value = ReadBlueLedSysfs();
1613 GTEST_LOG_(INFO) << "BatteryST071 executing, blue brightness value=" << value;
1614
1615 ASSERT_TRUE(value == 0);
1616 HDF_LOGD("%{public}s: enter. BatteryST071 end.", __func__);
1617 }
1618
1619 /**
1620 * @tc.name: BatteryST072
1621 * @tc.desc: Test Led color is red when capacity range in [90,100), critical value
1622 * @tc.type: FUNC
1623 */
1624 HWTEST_F (BatterySttest, BatteryST072, TestSize.Level1)
1625 {
1626 HDF_LOGD("%{public}s: enter. BatteryST072 start.", __func__);
1627
1628 int32_t chargestate = PowerSupplyProvider::CHARGE_STATE_ENABLE;
1629 int32_t capacity = 99;
1630 BatteryLed batteryled;
1631 UpdateLedColorTest(chargestate, capacity, batteryled);
1632
1633 int32_t value = ReadRedLedSysfs();
1634 GTEST_LOG_(INFO) << "BatteryST072 executing, red brightness value=" << value;
1635 ASSERT_TRUE(value == 0);
1636
1637 value = ReadGreenLedSysfs();
1638 GTEST_LOG_(INFO) << "BatteryST072 executing, green brightness value=" << value;
1639 ASSERT_TRUE(value == 255);
1640
1641 value = ReadBlueLedSysfs();
1642 GTEST_LOG_(INFO) << "BatteryST072 executing, blue brightness value=" << value;
1643
1644 ASSERT_TRUE(value == 0);
1645 HDF_LOGD("%{public}s: enter. BatteryST072 end.", __func__);
1646 }
1647
1648 /**
1649 * @tc.name: BatteryST073
1650 * @tc.desc: Test Led color is yellow when capacity is 100
1651 * @tc.type: FUNC
1652 */
1653 HWTEST_F (BatterySttest, BatteryST073, TestSize.Level1)
1654 {
1655 HDF_LOGD("%{public}s: enter. BatteryST073 start.", __func__);
1656
1657 int32_t chargestate = PowerSupplyProvider::CHARGE_STATE_ENABLE;
1658 int32_t capacity = 99;
1659 BatteryLed batteryled;
1660 UpdateLedColorTest(chargestate, capacity, batteryled);
1661
1662 int32_t value = ReadRedLedSysfs();
1663 GTEST_LOG_(INFO) << "BatteryST073 executing, red brightness value=" << value;
1664 ASSERT_TRUE(value == 0);
1665
1666 value = ReadGreenLedSysfs();
1667 GTEST_LOG_(INFO) << "BatteryST073 executing, green brightness value=" << value;
1668 ASSERT_TRUE(value == 255);
1669
1670 value = ReadBlueLedSysfs();
1671 GTEST_LOG_(INFO) << "BatteryST073 executing, blue brightness value=" << value;
1672
1673 ASSERT_TRUE(value == 0);
1674 HDF_LOGD("%{public}s: enter. BatteryST073 end.", __func__);
1675 }
1676