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 <algorithm>
17 #include <cmath>
18 #include <cstdio>
19 #include <gtest/gtest.h>
20 #include <fcntl.h>
21 #include <functional>
22 #include <securec.h>
23 #include <unistd.h>
24 
25 #include <fstream>
26 #include "v2_0/battery_interface_proxy.h"
27 #include "v2_0/ibattery_callback.h"
28 #include "v2_0/types.h"
29 
30 using namespace OHOS::HDI::Battery;
31 using namespace OHOS::HDI::Battery::V2_0;
32 using namespace testing::ext;
33 using namespace OHOS;
34 
35 namespace {
36 class BatteryCallback : public HDI::Battery::V2_0::IBatteryCallback {
37 public:
BatteryCallback()38     BatteryCallback() {};
39     ~BatteryCallback() override {};
40     int32_t Update(const HDI::Battery::V2_0::BatteryInfo& event) override
41     {
42         (void)event;
43         return 0;
44     };
45 };
46 
47 sptr<IBatteryInterface> g_batteryInterface = nullptr;
48 sptr<IBatteryCallback> g_callback = new BatteryCallback();
49 }
50 
51 class HdfBatteryHdiTest : public testing::Test {
52 public:
53     static void SetUpTestCase();
54     static void TearDownTestCase();
55     void SetUp();
56     void TearDown();
57     static int32_t ReadFile(const char *path, char *buf, size_t size);
58     static int32_t ConvertInt(const std::string &value);
59 };
60 
SetUpTestCase(void)61 void HdfBatteryHdiTest::SetUpTestCase(void)
62 {
63     g_batteryInterface = IBatteryInterface::Get(true);
64 }
65 
TearDownTestCase(void)66 void HdfBatteryHdiTest::TearDownTestCase(void)
67 {
68 }
69 
SetUp(void)70 void HdfBatteryHdiTest::SetUp(void)
71 {
72 }
73 
TearDown(void)74 void HdfBatteryHdiTest::TearDown(void)
75 {
76 }
77 
CreateFile(std::string path, std::string content)78 std::string CreateFile(std::string path, std::string content)
79 {
80     std::ofstream stream(path.c_str());
81     if (!stream.is_open()) {
82         printf("Cannot create file");
83         return nullptr;
84     }
85     stream << content.c_str() << std::endl;
86     stream.close();
87     return path;
88 }
89 
90 namespace {
91 /**
92   * @tc.name: HdfBatteryHdiTest001
93   * @tc.desc: Get a client and check whether the client is empty.
94   * @tc.type: FUNC
95   */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest001, TestSize.Level1)96 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest001, TestSize.Level1)
97 {
98     EXPECT_TRUE(nullptr != g_batteryInterface);
99 }
100 
101 /**
102   * @tc.name: HdfBatteryHdiTest002
103   * @tc.desc: Register
104   * @tc.type: FUNC
105   */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest002, TestSize.Level1)106 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest002, TestSize.Level1)
107 {
108     printf("HdfBatteryHdiTest002: start.");
109     int32_t ret = g_batteryInterface->Register(sptr<IBatteryCallback>(g_callback) = nullptr);
110     EXPECT_NE(0, ret) << "HdfBatteryHdiTest002 failed";
111 
112     printf("HdfBatteryHdiTest002: return.");
113 }
114 
115 /**
116   * @tc.name: HdfBatteryHdiTest003
117   * @tc.desc: UnRegister
118   * @tc.type: FUNC
119   */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest003, TestSize.Level1)120 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest003, TestSize.Level1)
121 {
122     printf("HdfBatteryHdiTest003: start.");
123     int32_t ret = g_batteryInterface->UnRegister();
124     EXPECT_EQ(0, ret) << "HdfBatteryHdiTest002 failed";
125 
126     printf("HdfBatteryHdiTest003: return.");
127 }
128 
129 /**
130   * @tc.name: HdfBatteryHdiTest004
131   * @tc.desc: ChangePath
132   * @tc.type: FUNC
133   */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest004, TestSize.Level1)134 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest004, TestSize.Level1)
135 {
136     printf("HdfBatteryHdiTest004: start.");
137     std::string path;
138     EXPECT_TRUE(HDF_SUCCESS == g_batteryInterface->ChangePath(path));
139 
140     printf("HdfBatteryHdiTest004: return.");
141 }
142 
143 /**
144   * @tc.name: HdfBatteryHdiTest005
145   * @tc.desc: GetCapacity
146   * @tc.type: FUNC
147   */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest005, TestSize.Level1)148 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest005, TestSize.Level1)
149 {
150     printf("HdfBatteryHdiTest005: start.");
151     int capacity;
152     g_batteryInterface->GetCapacity(capacity);
153     EXPECT_TRUE(capacity <= 100 && capacity >= 0);
154 
155     printf("HdfBatteryHdiTest005: return.");
156 }
157 
158 /**
159   * @tc.name: HdfBatteryHdiTest006
160   * @tc.desc: GetVoltage
161   * @tc.type: FUNC
162   */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest006, TestSize.Level1)163 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest006, TestSize.Level1)
164 {
165     printf("HdfBatteryHdiTest006: start.");
166     int voltage;
167     g_batteryInterface->GetVoltage(voltage);
168     EXPECT_TRUE(voltage >= 0);
169 
170     printf("HdfBatteryHdiTest006: return.");
171 }
172 
173 /**
174   * @tc.name: HdfBatteryHdiTest007
175   * @tc.desc: GetTemperature
176   * @tc.type: FUNC
177   */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest007, TestSize.Level1)178 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest007, TestSize.Level1)
179 {
180     printf("HdfBatteryHdiTest007: start.");
181     int temperature;
182     g_batteryInterface->GetTemperature(temperature);
183     EXPECT_TRUE(temperature >= 0 && temperature <= 600);
184 
185     printf("HdfBatteryHdiTest007: return.");
186 }
187 
188 /**
189   * @tc.name: HdfBatteryHdiTest008
190   * @tc.desc: GetHealthState
191   * @tc.type: FUNC
192   */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest008, TestSize.Level1)193 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest008, TestSize.Level1)
194 {
195     printf("HdfBatteryHdiTest007: start.");
196     OHOS::HDI::Battery::V2_0::BatteryHealthState healthState = OHOS::HDI::Battery::V2_0::BatteryHealthState(0);
197     g_batteryInterface->GetHealthState(healthState);
198     EXPECT_TRUE(healthState >= 0 && healthState <= 6);
199 
200     printf("HdfBatteryHdiTest007: return.");
201 }
202 
203 /**
204   * @tc.name: HdfBatteryHdiTest009
205   * @tc.desc: GetPluggedType
206   * @tc.type: FUNC
207   */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest009, TestSize.Level1)208 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest009, TestSize.Level1)
209 {
210     printf("HdfBatteryHdiTest009: start.");
211     OHOS::HDI::Battery::V2_0::BatteryPluggedType pluggedType = OHOS::HDI::Battery::V2_0::BatteryPluggedType(0);
212     g_batteryInterface->GetPluggedType(pluggedType);
213     EXPECT_TRUE(pluggedType >= OHOS::HDI::Battery::V2_0::BatteryPluggedType::PLUGGED_TYPE_NONE &&
214         pluggedType <= OHOS::HDI::Battery::V2_0::BatteryPluggedType::PLUGGED_TYPE_BUTT);
215 
216     printf("HdfBatteryHdiTest009: return.");
217 }
218 
219 /**
220   * @tc.name: HdfBatteryHdiTest010
221   * @tc.desc: GetChargeState
222   * @tc.type: FUNC
223   */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest010, TestSize.Level1)224 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest010, TestSize.Level1)
225 {
226     printf("HdfBatteryHdiTest010: start.");
227     OHOS::HDI::Battery::V2_0::BatteryChargeState chargeState = OHOS::HDI::Battery::V2_0::BatteryChargeState(0);
228     g_batteryInterface->GetChargeState(chargeState);
229     EXPECT_TRUE(chargeState >= 0 && chargeState <= 4);
230 
231     printf("HdfBatteryHdiTest010: return.");
232 }
233 
234 /**
235   * @tc.name: HdfBatteryHdiTest011
236   * @tc.desc: GetPresent
237   * @tc.type: FUNC
238   */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest011, TestSize.Level1)239 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest011, TestSize.Level1)
240 {
241     printf("HdfBatteryHdiTest011: start.");
242     bool present = false;
243     EXPECT_TRUE(HDF_SUCCESS == g_batteryInterface->GetPresent(present));
244     printf("HdfBatteryHdiTest011: return.");
245 }
246 
247 /**
248   * @tc.name: HdfBatteryHdiTest012
249   * @tc.desc: GetTechnology
250   * @tc.type: FUNC
251   */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest012, TestSize.Level1)252 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest012, TestSize.Level1)
253 {
254     printf("HdfBatteryHdiTest012: start.");
255     std::string technology;
256     g_batteryInterface->GetTechnology(technology);
257     EXPECT_FALSE(technology.empty());
258 
259     printf("HdfBatteryHdiTest012: return.");
260 }
261 
262 /**
263   * @tc.name: HdfBatteryHdiTest013
264   * @tc.desc: GetTotalEnergy
265   * @tc.type: FUNC
266   */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest013, TestSize.Level1)267 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest013, TestSize.Level1)
268 {
269     printf("HdfBatteryHdiTest013: start.");
270     int32_t totalEnergy = -1;
271     g_batteryInterface->GetTotalEnergy(totalEnergy);
272     EXPECT_TRUE(totalEnergy >= 0);
273 
274     printf("HdfBatteryHdiTest013: return.");
275 }
276 
277 /**
278   * @tc.name: HdfBatteryHdiTest014
279   * @tc.desc: GetCurrentAverage
280   * @tc.type: FUNC
281   */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest014, TestSize.Level1)282 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest014, TestSize.Level1)
283 {
284     printf("HdfBatteryHdiTest014: start.");
285     int curAverage = -1;
286     int32_t ret = g_batteryInterface->GetCurrentAverage(curAverage);
287     if (ret != 0) {
288         EXPECT_NE(0, curAverage);
289     } else {
290         EXPECT_EQ(0, ret);
291     }
292     printf("HdfBatteryHdiTest014: return.");
293 }
294 
295 /**
296   * @tc.name: HdfBatteryHdiTest015
297   * @tc.desc: GetCurrentNow
298   * @tc.type: FUNC
299   */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest015, TestSize.Level1)300 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest015, TestSize.Level1)
301 {
302     printf("HdfBatteryHdiTest015: start.");
303     int32_t nowCurr = -1;
304     int32_t ret = g_batteryInterface->GetCurrentNow(nowCurr);
305     EXPECT_EQ(0, ret);
306 
307     printf("HdfBatteryHdiTest015: return.");
308 }
309 
310 /**
311   * @tc.name: HdfBatteryHdiTest016
312   * @tc.desc: GetRemainEnergy
313   * @tc.type: FUNC
314   */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest016, TestSize.Level1)315 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest016, TestSize.Level1)
316 {
317     printf("HdfBatteryHdiTest016: start.");
318     int32_t remainEnergy = -1;
319     g_batteryInterface->GetRemainEnergy(remainEnergy);
320     EXPECT_TRUE(remainEnergy >= 0);
321 
322     printf("HdfBatteryHdiTest016: return.");
323 }
324 
325 /**
326   * @tc.name: HdfBatteryHdiTest017
327   * @tc.desc: GetBatteryInfo
328   * @tc.type: FUNC
329   */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest017, TestSize.Level1)330 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest017, TestSize.Level1)
331 {
332     printf("HdfBatteryHdiTest017: start.");
333     OHOS::HDI::Battery::V2_0::BatteryInfo event = {
334         .capacity = -1,
335     };
336     g_batteryInterface->GetBatteryInfo(event);
337     EXPECT_TRUE(-1 != event.capacity);
338 
339     printf("HdfBatteryHdiTest017: return.");
340 }
341 
342 /**
343  * @tc.name: HdfBatteryHdiTest018
344  * @tc.desc: GetChargeType
345  * @tc.type: FUNC
346  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest018, TestSize.Level1)347 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest018, TestSize.Level1)
348 {
349     printf("HdfBatteryHdiTest018: start.");
350     OHOS::HDI::Battery::V2_0::ChargeType chargeType = OHOS::HDI::Battery::V2_0::ChargeType(0);
351     g_batteryInterface->GetChargeType(chargeType);
352     EXPECT_TRUE(chargeType >= OHOS::HDI::Battery::V2_0::ChargeType::CHARGE_TYPE_NONE &&
353         chargeType <= OHOS::HDI::Battery::V2_0::ChargeType::CHARGE_TYPE_WIRELESS_SUPER_QUICK);
354 
355     printf("HdfBatteryHdiTest018: return.");
356 }
357 
358 /**
359  * @tc.name: HdfBatteryHdiTest019
360  * @tc.desc: Judgment ChargeType enum value of the Types.idl
361  * @tc.type: FUNC
362  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest019, TestSize.Level1)363 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest019, TestSize.Level1)
364 {
365     printf("HdfBatteryHdiTest019: start.");
366     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::ChargeType::CHARGE_TYPE_NONE == 0);
367     printf("HdfBatteryHdiTest019: return.");
368 }
369 
370 /**
371  * @tc.name: HdfBatteryHdiTest020
372  * @tc.desc: Test limit charging current
373  * @tc.type: FUNC
374  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest020, TestSize.Level1)375 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest020, TestSize.Level1)
376 {
377     std::string currentPath = "/data/service/el0/battery/current_limit";
378     CreateFile(currentPath, "");
379     ChargingLimit scLimit;
380     scLimit.type = TYPE_CURRENT;
381     scLimit.protocol = "sc";
382     scLimit.value = 1000;
383     ChargingLimit buckLimit;
384     buckLimit.type = TYPE_CURRENT;
385     buckLimit.protocol = "buck";
386     buckLimit.value = 1100;
387     std::vector<ChargingLimit> chargeLimitList;
388     chargeLimitList.push_back(scLimit);
389     chargeLimitList.push_back(buckLimit);
390     int32_t result = g_batteryInterface->SetChargingLimit(chargeLimitList);
391     EXPECT_EQ(true, result == ERR_OK);
392 
393     std::string line;
394     std::string chargeLimitStr;
395     std::string writeChargeInfo = scLimit.protocol + " " + std::to_string(scLimit.value) + "\n" +
396         buckLimit.protocol + " " + std::to_string(buckLimit.value) + "\n";
397     std::ifstream fin(currentPath.c_str());
398     if (fin) {
399         while (getline(fin, line)) {
400             chargeLimitStr += line + "\n";
401         }
402     }
403     EXPECT_EQ(true, chargeLimitStr == writeChargeInfo);
404 }
405 
406 /**
407  * @tc.name: HdfBatteryHdiTest021
408  * @tc.desc: Test limit charging voltage
409  * @tc.type: FUNC
410  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest021, TestSize.Level1)411 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest021, TestSize.Level1)
412 {
413     std::string voltagePath = "/data/service/el0/battery/voltage_limit";
414     CreateFile(voltagePath, "");
415     ChargingLimit scLimit;
416     scLimit.type = TYPE_VOLTAGE;
417     scLimit.protocol = "sc";
418     scLimit.value = 2000;
419     ChargingLimit buckLimit;
420     buckLimit.type = TYPE_VOLTAGE;
421     buckLimit.protocol = "buck";
422     buckLimit.value = 3000;
423     std::vector<ChargingLimit> chargeLimitList;
424     chargeLimitList.push_back(scLimit);
425     chargeLimitList.push_back(buckLimit);
426     int32_t result = g_batteryInterface->SetChargingLimit(chargeLimitList);
427     EXPECT_EQ(true, result == ERR_OK);
428 
429     std::string line;
430     std::string voltageLimitStr;
431     std::string writeVoltageInfo = scLimit.protocol + " " + std::to_string(scLimit.value) + "\n" +
432         buckLimit.protocol + " " + std::to_string(buckLimit.value) + "\n";
433     std::ifstream fin(voltagePath.c_str());
434     if (fin) {
435         while (getline(fin, line)) {
436             voltageLimitStr += line + "\n";
437         }
438     }
439     EXPECT_EQ(true, voltageLimitStr == writeVoltageInfo);
440 }
441 
442 /**
443  * @tc.name: HdfBatteryHdiTest022
444  * @tc.desc: Judgment BatteryHealthState enum value of the Types.idl
445  * @tc.type: FUNC
446  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest022, TestSize.Level3)447 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest022, TestSize.Level3)
448 {
449     printf("HdfBatteryHdiTest022: start.");
450     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::BatteryHealthState::BATTERY_HEALTH_UNKNOWN == 0);
451     printf("HdfBatteryHdiTest022: end.");
452 }
453 
454 /**
455  * @tc.name: HdfBatteryHdiTest023
456  * @tc.desc: Judgment BatteryHealthState enum value of the Types.idl
457  * @tc.type: FUNC
458  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest023, TestSize.Level3)459 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest023, TestSize.Level3)
460 {
461     printf("HdfBatteryHdiTest023: start.");
462     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::BatteryHealthState::BATTERY_HEALTH_GOOD == 1);
463     printf("HdfBatteryHdiTest023: end.");
464 }
465 
466 /**
467  * @tc.name: HdfBatteryHdiTest024
468  * @tc.desc: Judgment BatteryHealthState enum value of the Types.idl
469  * @tc.type: FUNC
470  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest024, TestSize.Level3)471 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest024, TestSize.Level3)
472 {
473     printf("HdfBatteryHdiTest024: start.");
474     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::BatteryHealthState::BATTERY_HEALTH_OVERHEAT == 2);
475     printf("HdfBatteryHdiTest024: end.");
476 }
477 
478 /**
479  * @tc.name: HdfBatteryHdiTest025
480  * @tc.desc: Judgment BatteryHealthState enum value of the Types.idl
481  * @tc.type: FUNC
482  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest025, TestSize.Level3)483 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest025, TestSize.Level3)
484 {
485     printf("HdfBatteryHdiTest025: start.");
486     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::BatteryHealthState::BATTERY_HEALTH_OVERVOLTAGE == 3);
487     printf("HdfBatteryHdiTest025: end.");
488 }
489 
490 /**
491  * @tc.name: HdfBatteryHdiTest026
492  * @tc.desc: Judgment BatteryHealthState enum value of the Types.idl
493  * @tc.type: FUNC
494  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest026, TestSize.Level3)495 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest026, TestSize.Level3)
496 {
497     printf("HdfBatteryHdiTest026: start.");
498     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::BatteryHealthState::BATTERY_HEALTH_COLD == 4);
499     printf("HdfBatteryHdiTest026: end.");
500 }
501 
502 /**
503  * @tc.name: HdfBatteryHdiTest027
504  * @tc.desc: Judgment BatteryHealthState enum value of the Types.idl
505  * @tc.type: FUNC
506  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest027, TestSize.Level3)507 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest027, TestSize.Level3)
508 {
509     printf("HdfBatteryHdiTest027: start.");
510     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::BatteryHealthState::BATTERY_HEALTH_DEAD == 5);
511     printf("HdfBatteryHdiTest027: end.");
512 }
513 
514 /**
515  * @tc.name: HdfBatteryHdiTest028
516  * @tc.desc: Judgment BatteryHealthState enum value of the Types.idl
517  * @tc.type: FUNC
518  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest028, TestSize.Level3)519 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest028, TestSize.Level3)
520 {
521     printf("HdfBatteryHdiTest028: start.");
522     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::BatteryHealthState::BATTERY_HEALTH_RESERVED == 6);
523     printf("HdfBatteryHdiTest028: end.");
524 }
525 
526 /**
527  * @tc.name: HdfBatteryHdiTest029
528  * @tc.desc: Judgment BatteryChargeState enum value of the Types.idl
529  * @tc.type: FUNC
530  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest029, TestSize.Level3)531 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest029, TestSize.Level3)
532 {
533     printf("HdfBatteryHdiTest029: start.");
534     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::BatteryChargeState::CHARGE_STATE_NONE == 0);
535     printf("HdfBatteryHdiTest029: end.");
536 }
537 
538 /**
539  * @tc.name: HdfBatteryHdiTest030
540  * @tc.desc: Judgment BatteryChargeState enum value of the Types.idl
541  * @tc.type: FUNC
542  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest030, TestSize.Level3)543 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest030, TestSize.Level3)
544 {
545     printf("HdfBatteryHdiTest030: start.");
546     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::BatteryChargeState::CHARGE_STATE_ENABLE == 1);
547     printf("HdfBatteryHdiTest030: end.");
548 }
549 
550 /**
551  * @tc.name: HdfBatteryHdiTest031
552  * @tc.desc: Judgment BatteryChargeState enum value of the Types.idl
553  * @tc.type: FUNC
554  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest031, TestSize.Level3)555 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest031, TestSize.Level3)
556 {
557     printf("HdfBatteryHdiTest031: start.");
558     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::BatteryChargeState::CHARGE_STATE_DISABLE == 2);
559     printf("HdfBatteryHdiTest031: end.");
560 }
561 
562 /**
563  * @tc.name: HdfBatteryHdiTest032
564  * @tc.desc: Judgment BatteryChargeState enum value of the Types.idl
565  * @tc.type: FUNC
566  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest032, TestSize.Level3)567 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest032, TestSize.Level3)
568 {
569     printf("HdfBatteryHdiTest032: start.");
570     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::BatteryChargeState::CHARGE_STATE_FULL == 3);
571     printf("HdfBatteryHdiTest032: end.");
572 }
573 
574 /**
575  * @tc.name: HdfBatteryHdiTest033
576  * @tc.desc: Judgment BatteryChargeState enum value of the Types.idl
577  * @tc.type: FUNC
578  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest033, TestSize.Level3)579 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest033, TestSize.Level3)
580 {
581     printf("HdfBatteryHdiTest033: start.");
582     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::BatteryChargeState::CHARGE_STATE_RESERVED == 4);
583     printf("HdfBatteryHdiTest033: end.");
584 }
585 
586 /**
587  * @tc.name: HdfBatteryHdiTest034
588  * @tc.desc: Judgment BatteryPluggedType enum value of the Types.idl
589  * @tc.type: FUNC
590  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest034, TestSize.Level3)591 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest034, TestSize.Level3)
592 {
593     printf("HdfBatteryHdiTest034: start.");
594     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::BatteryPluggedType::PLUGGED_TYPE_NONE == 0);
595     printf("HdfBatteryHdiTest034: end.");
596 }
597 
598 /**
599  * @tc.name: HdfBatteryHdiTest035
600  * @tc.desc: Judgment BatteryPluggedType enum value of the Types.idl
601  * @tc.type: FUNC
602  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest035, TestSize.Level3)603 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest035, TestSize.Level3)
604 {
605     printf("HdfBatteryHdiTest035: start.");
606     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::BatteryPluggedType::PLUGGED_TYPE_AC == 1);
607     printf("HdfBatteryHdiTest035: end.");
608 }
609 
610 /**
611  * @tc.name: HdfBatteryHdiTest036
612  * @tc.desc: Judgment BatteryPluggedType enum value of the Types.idl
613  * @tc.type: FUNC
614  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest036, TestSize.Level3)615 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest036, TestSize.Level3)
616 {
617     printf("HdfBatteryHdiTest036: start.");
618     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::BatteryPluggedType::PLUGGED_TYPE_USB == 2);
619     printf("HdfBatteryHdiTest036: end.");
620 }
621 
622 /**
623  * @tc.name: HdfBatteryHdiTest037
624  * @tc.desc: Judgment BatteryPluggedType enum value of the Types.idl
625  * @tc.type: FUNC
626  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest037, TestSize.Level3)627 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest037, TestSize.Level3)
628 {
629     printf("HdfBatteryHdiTest037: start.");
630     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::BatteryPluggedType::PLUGGED_TYPE_WIRELESS == 3);
631     printf("HdfBatteryHdiTest037: end.");
632 }
633 
634 /**
635  * @tc.name: HdfBatteryHdiTest038
636  * @tc.desc: Judgment BatteryPluggedType enum value of the Types.idl
637  * @tc.type: FUNC
638  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest038, TestSize.Level3)639 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest038, TestSize.Level3)
640 {
641     printf("HdfBatteryHdiTest038: start.");
642     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::BatteryPluggedType::PLUGGED_TYPE_BUTT == 4);
643     printf("HdfBatteryHdiTest038: end.");
644 }
645 
646 /**
647  * @tc.name: HdfBatteryHdiTest039
648  * @tc.desc: Judgment ChargingLimitType enum value of the Types.idl
649  * @tc.type: FUNC
650  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest039, TestSize.Level3)651 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest039, TestSize.Level3)
652 {
653     printf("HdfBatteryHdiTest039: start.");
654     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::ChargingLimitType::TYPE_CURRENT == 0);
655     printf("HdfBatteryHdiTest039: end.");
656 }
657 
658 /**
659  * @tc.name: HdfBatteryHdiTest040
660  * @tc.desc: Judgment ChargingLimitType enum value of the Types.idl
661  * @tc.type: FUNC
662  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest040, TestSize.Level3)663 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest040, TestSize.Level3)
664 {
665     printf("HdfBatteryHdiTest040: start.");
666     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::ChargingLimitType::TYPE_VOLTAGE == 1);
667     printf("HdfBatteryHdiTest040: end.");
668 }
669 
670 
671 /**
672  * @tc.name: HdfBatteryHdiTest041
673  * @tc.desc: Judgment ChargeType enum value of the Types.idl
674  * @tc.type: FUNC
675  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest041, TestSize.Level3)676 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest041, TestSize.Level3)
677 {
678     printf("HdfBatteryHdiTest041: start.");
679     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::ChargeType::CHARGE_TYPE_WIRED_NORMAL == 1);
680     printf("HdfBatteryHdiTest041: end.");
681 }
682 
683 /**
684  * @tc.name: HdfBatteryHdiTest042
685  * @tc.desc: Judgment ChargeType enum value of the Types.idl
686  * @tc.type: FUNC
687  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest042, TestSize.Level3)688 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest042, TestSize.Level3)
689 {
690     printf("HdfBatteryHdiTest042: start.");
691     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::ChargeType::CHARGE_TYPE_WIRED_QUICK == 2);
692     printf("HdfBatteryHdiTest042: end.");
693 }
694 
695 /**
696  * @tc.name: HdfBatteryHdiTest043
697  * @tc.desc: Judgment ChargeType enum value of the Types.idl
698  * @tc.type: FUNC
699  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest043, TestSize.Level3)700 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest043, TestSize.Level3)
701 {
702     printf("HdfBatteryHdiTest043: start.");
703     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::ChargeType::CHARGE_TYPE_WIRED_SUPER_QUICK == 3);
704     printf("HdfBatteryHdiTest043: end.");
705 }
706 
707 /**
708  * @tc.name: HdfBatteryHdiTest044
709  * @tc.desc: Judgment ChargeType enum value of the Types.idl
710  * @tc.type: FUNC
711  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest044, TestSize.Level3)712 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest044, TestSize.Level3)
713 {
714     printf("HdfBatteryHdiTest044: start.");
715     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::ChargeType::CHARGE_TYPE_WIRELESS_NORMAL == 4);
716     printf("HdfBatteryHdiTest044: end.");
717 }
718 
719 /**
720  * @tc.name: HdfBatteryHdiTest045
721  * @tc.desc: Judgment ChargeType enum value of the Types.idl
722  * @tc.type: FUNC
723  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest045, TestSize.Level3)724 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest045, TestSize.Level3)
725 {
726     printf("HdfBatteryHdiTest045: start.");
727     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::ChargeType::CHARGE_TYPE_WIRELESS_QUICK == 5);
728     printf("HdfBatteryHdiTest045: end.");
729 }
730 
731 /**
732  * @tc.name: HdfBatteryHdiTest046
733  * @tc.desc: Judgment ChargeType enum value of the Types.idl
734  * @tc.type: FUNC
735  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest046, TestSize.Level3)736 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest046, TestSize.Level3)
737 {
738     printf("HdfBatteryHdiTest046: start.");
739     EXPECT_TRUE(OHOS::HDI::Battery::V2_0::ChargeType::CHARGE_TYPE_WIRELESS_SUPER_QUICK == 6);
740     printf("HdfBatteryHdiTest046: end.");
741 }
742 
743 /**
744  * @tc.name: HdfBatteryHdiTest047
745  * @tc.desc: Test SetBatteryConfig
746  * @tc.type: FUNC
747  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest047, TestSize.Level1)748 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest047, TestSize.Level1)
749 {
750     std::string sceneName = "xxx";
751     std::string value = "";
752     int32_t result = g_batteryInterface->SetBatteryConfig(sceneName, value);
753     EXPECT_EQ(true, result != 0);
754 }
755 
756 /**
757  * @tc.name: HdfBatteryHdiTest048
758  * @tc.desc: Test GetBatteryConfig
759  * @tc.type: FUNC
760  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest048, TestSize.Level1)761 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest048, TestSize.Level1)
762 {
763     std::string sceneName = "xxx";
764     std::string value = "";
765     int32_t result = g_batteryInterface->GetBatteryConfig(sceneName, value);
766     EXPECT_EQ(true, value == "");
767     EXPECT_EQ(true, result != 0);
768 }
769 
770 /**
771  * @tc.name: HdfBatteryHdiTest049
772  * @tc.desc: Test IsBatteryConfigSupported
773  * @tc.type: FUNC
774  */
HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest049, TestSize.Level1)775 HWTEST_F(HdfBatteryHdiTest, HdfBatteryHdiTest049, TestSize.Level1)
776 {
777     std::string sceneName = "xxx";
778     bool value = false;
779     int32_t result = g_batteryInterface->IsBatteryConfigSupported(sceneName, value);
780     EXPECT_EQ(true, value == false);
781     EXPECT_EQ(true, result != 0);
782 }
783 }
784