1 /*
2  * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "battery_client_test.h"
17 
18 #ifdef GTEST
19 #define private   public
20 #define protected public
21 #endif
22 
23 #include <iostream>
24 #include <string>
25 #include <gtest/gtest.h>
26 
27 #include "if_system_ability_manager.h"
28 #include "iremote_broker.h"
29 #include "iservice_registry.h"
30 #include "system_ability_definition.h"
31 
32 #include "battery_log.h"
33 #include "battery_srv_client.h"
34 #include "test_utils.h"
35 
36 using namespace testing::ext;
37 using namespace OHOS::PowerMgr;
38 using namespace OHOS;
39 using namespace std;
40 
41 namespace {
42 bool g_isMock = false;
43 constexpr int32_t BATTERY_EMERGENCY_THRESHOLD = 5;
44 constexpr int32_t BATTERY_DEFAULT_THRESHOLD = 10;
45 constexpr int32_t BATTERY_LOW_THRESHOLD = 20;
46 constexpr int32_t BATTERY_NORMAL_THRESHOLD = 90;
47 constexpr int32_t BATTERY_HIGH_THRESHOLD = 99;
48 constexpr int32_t BATTERY_HIGH_FULL = 100;
49 const std::string MOCK_BATTERY_PATH = "/data/service/el0/battery/";
50 BatteryInfo g_info;
51 }
52 
SetUpTestCase(void)53 void BatteryClientTest::SetUpTestCase(void)
54 {
55     g_isMock = TestUtils::IsMock();
56     GTEST_LOG_(INFO) << " g_isMock: " << g_isMock;
57 }
58 
TearDownTestCase(void)59 void BatteryClientTest::TearDownTestCase(void)
60 {
61     g_isMock = false;
62     TestUtils::ResetOnline();
63 }
64 
SetUp(void)65 void BatteryClientTest::SetUp(void)
66 {
67     g_info.SetCapacity(BATTERY_HIGH_FULL);
68     g_info.SetPresent(false);
69     g_info.SetVoltage(BATTERY_DEFAULT_THRESHOLD);
70     g_info.SetTemperature(BATTERY_DEFAULT_THRESHOLD);
71     g_info.SetHealthState(BatteryHealthState::HEALTH_STATE_GOOD);
72     g_info.SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_USB);
73     g_info.SetPluggedMaxCurrent(BATTERY_DEFAULT_THRESHOLD);
74     g_info.SetPluggedMaxVoltage(BATTERY_DEFAULT_THRESHOLD);
75     g_info.SetChargeState(BatteryChargeState::CHARGE_STATE_DISABLE);
76     g_info.SetChargeCounter(BATTERY_DEFAULT_THRESHOLD);
77     g_info.SetTotalEnergy(BATTERY_DEFAULT_THRESHOLD);
78     g_info.SetCurAverage(BATTERY_DEFAULT_THRESHOLD);
79     g_info.SetNowCurrent(BATTERY_DEFAULT_THRESHOLD);
80     g_info.SetRemainEnergy(BATTERY_DEFAULT_THRESHOLD);
81     g_info.SetTechnology("test");
82 }
83 
TearDown(void)84 void BatteryClientTest::TearDown(void)
85 {
86 }
87 
88 namespace {
89 /**
90  * @tc.name: BatteryClient001
91  * @tc.desc: Test IBatterySrv interface GetCapacity
92  * @tc.type: FUNC
93  */
94 HWTEST_F (BatteryClientTest, BatteryClient001, TestSize.Level1)
95 {
96     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient001 start.");
97 
98     auto& BatterySrvClient = BatterySrvClient::GetInstance();
99     if (g_isMock) {
100         auto tempCapacity = BatterySrvClient.GetCapacity();
101         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "22");
102         auto capacity = BatterySrvClient.GetCapacity();
103         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::capacity=%{public}d", capacity);
104         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient001 executing, capacity=" << capacity;
105         ASSERT_TRUE(capacity == 22);
106         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", std::to_string(tempCapacity));
107     } else {
108         auto capacity = BatterySrvClient.GetCapacity();
109         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::capacity=%{public}d", capacity);
110         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient001 executing, capacity=" << capacity;
111         ASSERT_TRUE(capacity <= 100 && capacity >= 0);
112     }
113 
114     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient001 end.");
115 }
116 
117 /**
118  * @tc.name: BatteryClient002
119  * @tc.desc: Test IBatterySrv interface GetChargingStatus
120  * @tc.type: FUNC
121  */
122 
123 HWTEST_F (BatteryClientTest, BatteryClient002, TestSize.Level1)
124 {
125     auto& BatterySrvClient = BatterySrvClient::GetInstance();
126     if (g_isMock) {
127         auto tempChargeState = BatterySrvClient.GetChargingStatus();
128         std::string chargeStateArr[] = {"Discharging", "Charging", "Not charging", "Full", "Unknown"};
129 
130         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status", "Not charging");
131         auto chargeState = BatterySrvClient.GetChargingStatus();
132         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::chargeState=%{public}d",
133             static_cast<int32_t>(chargeState));
134         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient002 executing, chargeState="
135             << static_cast<int32_t>(chargeState);
136         ASSERT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_DISABLE);
137 
138         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status",
139             chargeStateArr[static_cast<int32_t>(tempChargeState)]);
140     } else {
141         auto chargeState = BatterySrvClient.GetChargingStatus();
142         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::chargeState=%{public}d",
143             static_cast<int32_t>(chargeState));
144         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient002 executing, chargeState="
145             << static_cast<int32_t>(chargeState);
146         ASSERT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_ENABLE ||
147             chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_FULL);
148     }
149     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient002 end.");
150 }
151 
152 /**
153  * @tc.name: BatteryClient003
154  * @tc.desc: Test IBatterySrv interface GetHealthStatus
155  * @tc.type: FUNC
156  */
157 HWTEST_F (BatteryClientTest, BatteryClient003, TestSize.Level1)
158 {
159     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient003 start.");
160     auto& BatterySrvClient = BatterySrvClient::GetInstance();
161     if (g_isMock) {
162         auto tempHealthState = BatterySrvClient.GetHealthStatus();
163         std::string healthStateArr[] = {"Unknown", "Good", "Hot", "Over voltage", "Cold", "Dead"};
164 
165         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health", "Cold");
166         auto healthState = BatterySrvClient.GetHealthStatus();
167         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::healthState=%{public}d",
168             static_cast<int32_t>(healthState));
169         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient003 executing, healthState="
170             << static_cast<int32_t>(healthState);
171         ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_COLD);
172 
173         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health",
174             healthStateArr[static_cast<int32_t>(tempHealthState)]);
175     } else {
176         auto healthState = BatterySrvClient.GetHealthStatus();
177         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::healthState=%{public}d",
178             static_cast<int32_t>(healthState));
179         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient003 executing, healthState="
180             << static_cast<int32_t>(healthState);
181         ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
182     }
183     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient003 end.");
184 }
185 
186 /**
187  * @tc.name: BatteryClient004
188  * @tc.desc: Test IBatterySrv interface GetPresent
189  * @tc.type: FUNC
190  */
191 HWTEST_F (BatteryClientTest, BatteryClient004, TestSize.Level1)
192 {
193     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient004 start.");
194     auto& BatterySrvClient = BatterySrvClient::GetInstance();
195     if (g_isMock) {
196         auto tempPresent = BatterySrvClient.GetPresent();
197         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", "0");
198         auto present = BatterySrvClient.GetPresent();
199         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::present=%{public}d", present);
200         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient004 executing, present=" << present;
201         ASSERT_FALSE(present);
202 
203         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", std::to_string(tempPresent));
204     } else {
205         auto present = BatterySrvClient.GetPresent();
206         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::present=%{public}d", present);
207         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient004 executing, present=" << present;
208         ASSERT_TRUE(present);
209     }
210     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient004 end.");
211 }
212 
213 /**
214  * @tc.name: BatteryClient005
215  * @tc.desc: Test IBatterySrv interface GetVoltage
216  * @tc.type: FUNC
217  */
218 HWTEST_F (BatteryClientTest, BatteryClient005, TestSize.Level1)
219 {
220     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient005 start.");
221     auto& BatterySrvClient = BatterySrvClient::GetInstance();
222     if (g_isMock) {
223         auto tempVoltage = BatterySrvClient.GetVoltage();
224         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", "4654321");
225         auto voltage = BatterySrvClient.GetVoltage();
226         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::voltage=%{public}d", voltage);
227         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient005 executing, voltage=" << voltage;
228         ASSERT_TRUE(voltage == 4654321);
229 
230         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", std::to_string(tempVoltage));
231     } else {
232         auto voltage = BatterySrvClient.GetVoltage();
233         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::voltage=%{public}d", voltage);
234         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient005 executing, voltage=" << voltage;
235         ASSERT_TRUE(voltage >= 0);
236     }
237     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient005 end.");
238 }
239 
240 /**
241  * @tc.name: BatteryClient006
242  * @tc.desc: Test IBatterySrv interface GetTemperature
243  * @tc.type: FUNC
244  */
245 HWTEST_F (BatteryClientTest, BatteryClient006, TestSize.Level1)
246 {
247     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient006 start.");
248     auto& BatterySrvClient = BatterySrvClient::GetInstance();
249     if (g_isMock) {
250         auto tempTempPresent = BatterySrvClient.GetBatteryTemperature();
251         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", "222");
252         auto temperature = BatterySrvClient.GetBatteryTemperature();
253         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::temperature=%{public}d", temperature);
254         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient006 executing, temperature=" << temperature;
255         ASSERT_TRUE(temperature == 222);
256 
257         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", std::to_string(tempTempPresent));
258     } else {
259         auto temperature = BatterySrvClient.GetBatteryTemperature();
260         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::temperature=%{public}d", temperature);
261         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient006 executing, temperature=" << temperature;
262         ASSERT_TRUE(temperature >= 0 && temperature <= 600);
263     }
264     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient006 end.");
265 }
266 
267 /**
268  * @tc.name: BatteryClient007
269  * @tc.desc: Test IBatterySrv interface GetTechnology
270  * @tc.type: FUNC
271  */
272 HWTEST_F (BatteryClientTest, BatteryClient007, TestSize.Level1)
273 {
274     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient007 start.");
275     auto& BatterySrvClient = BatterySrvClient::GetInstance();
276     if (g_isMock) {
277         std::string tempTechnology = BatterySrvClient.GetTechnology();
278         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos-fgu/technology", "H2");
279         auto technology = BatterySrvClient.GetTechnology();
280         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::technology=%{public}s", technology.c_str());
281         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient007 executing, technology=" << technology;
282         ASSERT_TRUE(technology == "H2");
283 
284         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos-fgu/technology", tempTechnology);
285     } else {
286         auto technology = BatterySrvClient.GetTechnology();
287         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::technology=%{public}s", technology.c_str());
288         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient007 executing, technology=" << technology;
289         ASSERT_TRUE(technology == "Li-poly");
290     }
291     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient007 end.");
292 }
293 
294 /**
295  * @tc.name: BatteryClient008
296  * @tc.desc: Test IBatterySrv interface GetPluggedType
297  * @tc.type: FUNC
298  */
299 HWTEST_F (BatteryClientTest, BatteryClient008, TestSize.Level1)
300 {
301     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient008 start.");
302     auto& BatterySrvClient = BatterySrvClient::GetInstance();
303     if (g_isMock) {
304         TestUtils::ResetOnline();
305         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/online", "1");
306         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/type", "USB");
307         auto pluggedType = BatterySrvClient.GetPluggedType();
308 
309         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::pluggedType=%{public}d",
310             static_cast<int32_t>(pluggedType));
311         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient008 executing, pluggedType="
312             << static_cast<int32_t>(pluggedType);
313 
314         ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_USB);
315     } else {
316         auto pluggedType = BatterySrvClient.GetPluggedType();
317         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::pluggedType=%{public}d",
318             static_cast<int32_t>(pluggedType));
319         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient008 executing, pluggedType="
320             << static_cast<int32_t>(pluggedType);
321         ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_USB);
322     }
323     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient008 end.");
324 }
325 
326 /**
327  * @tc.name: BatteryClient009
328  * @tc.desc: Test IBatterySrv interface GetCurrentNow
329  * @tc.type: FUNC
330  */
331 HWTEST_F (BatteryClientTest, BatteryClient009, TestSize.Level1)
332 {
333     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient009 start.");
334     auto& BatterySrvClient = BatterySrvClient::GetInstance();
335     if (g_isMock) {
336         auto tempCurrnow = BatterySrvClient.GetNowCurrent();
337         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/current_now", "4654321");
338         auto currnow = BatterySrvClient.GetNowCurrent();
339         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::current=%{public}d", currnow);
340         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient009 executing, currnow=" << currnow;
341         ASSERT_EQ(currnow, 4654321);
342 
343         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/current_now", std::to_string(tempCurrnow));
344     } else {
345         auto currnow = BatterySrvClient.GetNowCurrent();
346         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::currnow=%{public}d", currnow);
347         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient009 executing, currnow=" << currnow;
348         ASSERT_TRUE(currnow >= -20000 && currnow <= 20000);
349     }
350     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient009 end.");
351 }
352 
353 /**
354  * @tc.name: BatteryClient010
355  * @tc.desc: Test IBatterySrv interface GetRemainEnergy
356  * @tc.type: FUNC
357  */
358 HWTEST_F (BatteryClientTest, BatteryClient010, TestSize.Level1)
359 {
360     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient010 start.");
361     auto& BatterySrvClient = BatterySrvClient::GetInstance();
362     if (g_isMock) {
363         auto tempChargenow = BatterySrvClient.GetRemainEnergy();
364         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/charge_now", "4654321");
365         auto chargenow = BatterySrvClient.GetRemainEnergy();
366         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::chargenow=%{public}d", chargenow);
367         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient010 executing, chargenow=" << chargenow;
368         ASSERT_EQ(chargenow, 4654321);
369 
370         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/charge_now", std::to_string(tempChargenow));
371     } else {
372         auto chargenow = BatterySrvClient.GetRemainEnergy();
373         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::chargenow=%{public}d", chargenow);
374         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient010 executing, chargenow=" << chargenow;
375         ASSERT_TRUE(chargenow >= 0);
376     }
377     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient010 end.");
378 }
379 
380 /**
381  * @tc.name: BatteryClient011
382  * @tc.desc: Test IBatterySrv interface GetTotalEnergy
383  * @tc.type: FUNC
384  */
385 HWTEST_F (BatteryClientTest, BatteryClient011, TestSize.Level1)
386 {
387     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient011 start.");
388     auto& BatterySrvClient = BatterySrvClient::GetInstance();
389     if (g_isMock) {
390         auto tempTotalenergy = BatterySrvClient.GetTotalEnergy();
391         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/charge_full", "4654321");
392         auto totalenergy = BatterySrvClient.GetTotalEnergy();
393         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::totalenergy=%{public}d", totalenergy);
394         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient011 executing, totalenergy=" << totalenergy;
395         ASSERT_EQ(totalenergy, 4654321);
396 
397         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/charge_full", std::to_string(tempTotalenergy));
398     } else {
399         auto totalenergy = BatterySrvClient.GetTotalEnergy();
400         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::totalenergy=%{public}d", totalenergy);
401         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient011 executing, totalenergy=" << totalenergy;
402         ASSERT_TRUE(totalenergy >= 0);
403     }
404     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient011 end.");
405 }
406 
407 /**
408  * @tc.name: BatteryClient012
409  * @tc.desc: Test IBatterySrv interface GetCapacityLevel
410  * @tc.type: FUNC
411  */
412 HWTEST_F (BatteryClientTest, BatteryClient012, TestSize.Level1)
413 {
414     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient012 start.");
415     auto& BatterySrvClient = BatterySrvClient::GetInstance();
416     if (g_isMock) {
417         auto tempCapacity = BatterySrvClient.GetCapacity();
418         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "3");
419         auto batterylevel = BatterySrvClient.GetCapacityLevel();
420         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
421             static_cast<int32_t>(batterylevel));
422         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient012 executing, batterylevel="
423             << static_cast<int32_t>(batterylevel);
424         ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_CRITICAL);
425 
426         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", std::to_string(tempCapacity));
427     } else {
428         auto batterylevel = BatterySrvClient.GetCapacityLevel();
429         auto capacity = BatterySrvClient.GetCapacity();
430         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
431             static_cast<int32_t>(batterylevel));
432         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient012 executing, batterylevel="
433             << static_cast<int32_t>(batterylevel);
434         if (capacity < BATTERY_EMERGENCY_THRESHOLD) {
435             ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_CRITICAL);
436         }
437     }
438     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient012 end.");
439 }
440 
441 /**
442  * @tc.name: BatteryClient013
443  * @tc.desc: Test IBatterySrv interface GetCapacityLevel
444  * @tc.type: FUNC
445  */
446 HWTEST_F (BatteryClientTest, BatteryClient013, TestSize.Level1)
447 {
448     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient013 start.");
449     auto& BatterySrvClient = BatterySrvClient::GetInstance();
450     if (g_isMock) {
451         auto tempCapacity = BatterySrvClient.GetCapacity();
452         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "11");
453         auto batterylevel = BatterySrvClient.GetCapacityLevel();
454         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
455             static_cast<int32_t>(batterylevel));
456         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient013 executing, batterylevel="
457             << static_cast<int32_t>(batterylevel);
458         ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_LOW);
459 
460         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", std::to_string(tempCapacity));
461     } else {
462         auto batterylevel = BatterySrvClient.GetCapacityLevel();
463         auto capacity = BatterySrvClient.GetCapacity();
464         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
465             static_cast<int32_t>(batterylevel));
466         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient013 executing, batterylevel="
467             << static_cast<int32_t>(batterylevel);
468         if (capacity >= BATTERY_EMERGENCY_THRESHOLD && capacity <= BATTERY_LOW_THRESHOLD) {
469             ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_LOW);
470         }
471     }
472     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient013 end.");
473 }
474 
475 /**
476  * @tc.name: BatteryClient014
477  * @tc.desc: Test IBatterySrv interface GetCapacityLevel
478  * @tc.type: FUNC
479  */
480 HWTEST_F (BatteryClientTest, BatteryClient014, TestSize.Level1)
481 {
482     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient014 start.");
483     auto& BatterySrvClient = BatterySrvClient::GetInstance();
484     if (g_isMock) {
485         auto tempCapacity = BatterySrvClient.GetCapacity();
486         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "80");
487         auto batterylevel = BatterySrvClient.GetCapacityLevel();
488         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
489             static_cast<int32_t>(batterylevel));
490         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient014 executing, batterylevel="
491             << static_cast<int32_t>(batterylevel);
492         ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_NORMAL);
493 
494         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", std::to_string(tempCapacity));
495     } else {
496         auto batterylevel = BatterySrvClient.GetCapacityLevel();
497         auto capacity = BatterySrvClient.GetCapacity();
498         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
499             static_cast<int32_t>(batterylevel));
500         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient014 executing, batterylevel="
501             << static_cast<int32_t>(batterylevel);
502         if (capacity > BATTERY_LOW_THRESHOLD && capacity <= BATTERY_NORMAL_THRESHOLD) {
503             ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_NORMAL);
504         }
505     }
506     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient014 end.");
507 }
508 
509 /**
510  * @tc.name: BatteryClient015
511  * @tc.desc: Test IBatterySrv interface GetCapacityLevel
512  * @tc.type: FUNC
513  */
514 HWTEST_F (BatteryClientTest, BatteryClient015, TestSize.Level1)
515 {
516     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient015 start.");
517     auto& BatterySrvClient = BatterySrvClient::GetInstance();
518     if (g_isMock) {
519         auto tempCapacity = BatterySrvClient.GetCapacity();
520         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "94");
521         auto batterylevel = BatterySrvClient.GetCapacityLevel();
522         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
523             static_cast<int32_t>(batterylevel));
524         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient015 executing, batterylevel="
525             << static_cast<int32_t>(batterylevel);
526         ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_HIGH);
527 
528         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", std::to_string(tempCapacity));
529     } else {
530         auto batterylevel = BatterySrvClient.GetCapacityLevel();
531         auto capacity = BatterySrvClient.GetCapacity();
532         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
533             static_cast<int32_t>(batterylevel));
534         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient015 executing, batterylevel="
535             << static_cast<int32_t>(batterylevel);
536         if (capacity > BATTERY_NORMAL_THRESHOLD && capacity <= BATTERY_HIGH_THRESHOLD) {
537             ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_HIGH);
538         }
539     }
540     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient015 end.");
541 }
542 
543 /**
544  * @tc.name: BatteryClient016
545  * @tc.desc: Test IBatterySrv interface GetCapacityLevel
546  * @tc.type: FUNC
547  */
548 HWTEST_F (BatteryClientTest, BatteryClient016, TestSize.Level1)
549 {
550     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient016 start.");
551     auto& BatterySrvClient = BatterySrvClient::GetInstance();
552     if (g_isMock) {
553         auto tempCapacity = BatterySrvClient.GetCapacity();
554         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "100");
555         auto batterylevel = BatterySrvClient.GetCapacityLevel();
556         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
557            static_cast<int32_t>(batterylevel));
558         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient016 executing, batterylevel="
559            << static_cast<int32_t>(batterylevel);
560         ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_FULL);
561 
562         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", std::to_string(tempCapacity));
563     } else {
564         auto batterylevel = BatterySrvClient.GetCapacityLevel();
565         auto capacity = BatterySrvClient.GetCapacity();
566         BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
567             static_cast<int32_t>(batterylevel));
568         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient016 executing, batterylevel="
569             << static_cast<int32_t>(batterylevel);
570         if (capacity == BATTERY_HIGH_FULL) {
571             ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_FULL);
572         }
573     }
574     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient016 end.");
575 }
576 
577 
578 /**
579  * @tc.name: BatteryClient017
580  * @tc.desc: Test IBatterySrv interface GetRemainingChargeTime
581  * @tc.type: FUNC
582  */
583 HWTEST_F (BatteryClientTest, BatteryClient017, TestSize.Level1)
584 {
585     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient017 start.");
586     auto& BatterySrvClient = BatterySrvClient::GetInstance();
587     if (g_isMock) {
588         auto remainingChargeTime = BatterySrvClient.GetRemainingChargeTime();
589         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient017 executing, remainingChargeTime=" << remainingChargeTime;
590         ASSERT_TRUE(remainingChargeTime >= 0);
591     } else {
592         auto remainingChargeTime = BatterySrvClient.GetRemainingChargeTime();
593         GTEST_LOG_(INFO) << "BatteryClient::BatteryClient017 executing, remainingChargeTime=" << remainingChargeTime;
594         ASSERT_TRUE(remainingChargeTime >= 0);
595     }
596     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient017 end.");
597 }
598 
599 /**
600  * @tc.name: BatteryClient018
601  * @tc.desc: Test BatteryInfo operator== and operator!=
602  * @tc.type: FUNC
603  */
604 HWTEST_F(BatteryClientTest, BatteryClient018, TestSize.Level1)
605 {
606     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient018 start.");
607     {
608         BatteryInfo info1;
609         info1.SetCapacity(100);
610         info1.SetPresent(false);
611         info1.SetVoltage(10);
612         info1.SetTemperature(10);
613         info1.SetHealthState(BatteryHealthState::HEALTH_STATE_GOOD);
614         info1.SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_USB);
615         info1.SetPluggedMaxCurrent(10);
616         info1.SetPluggedMaxVoltage(10);
617         info1.SetChargeState(BatteryChargeState::CHARGE_STATE_DISABLE);
618         info1.SetChargeCounter(10);
619         info1.SetTotalEnergy(10);
620         info1.SetCurAverage(10);
621         info1.SetNowCurrent(10);
622         info1.SetRemainEnergy(10);
623         info1.SetTechnology("BatteryClient018");
624         BatteryInfo info2;
625         info2.SetCapacity(100);
626         info2.SetPresent(false);
627         info2.SetVoltage(10);
628         info2.SetTemperature(10);
629         info2.SetHealthState(BatteryHealthState::HEALTH_STATE_GOOD);
630         info2.SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_USB);
631         info2.SetPluggedMaxCurrent(10);
632         info2.SetPluggedMaxVoltage(10);
633         info2.SetChargeState(BatteryChargeState::CHARGE_STATE_DISABLE);
634         info2.SetChargeCounter(10);
635         info2.SetTotalEnergy(10);
636         info2.SetCurAverage(10);
637         info2.SetNowCurrent(10);
638         info2.SetRemainEnergy(10);
639         info2.SetTechnology("BatteryClient018");
640         ASSERT_TRUE(info1 == info2);
641         ASSERT_FALSE(info1 != info2);
642         info1.SetTechnology("BatteryClient018_false");
643         ASSERT_FALSE(info1 == info2);
644         ASSERT_TRUE(info1 != info2);
645     }
646     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient018 end.");
647 }
648 
649 /**
650  * @tc.name: BatteryClient019
651  * @tc.desc: Test BatteryInfo operator==
652  * @tc.type: FUNC
653  */
654 HWTEST_F(BatteryClientTest, BatteryClient019, TestSize.Level1)
655 {
656     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient019 start.");
657     BatteryInfo info1 = g_info;
658     info1.SetPresent(false);
659     BatteryInfo info2 = g_info;
660     info2.SetPresent(true);
661     ASSERT_FALSE(info1 == info2);
662 
663     info1 = info2 = g_info;
664     info1.SetCapacity(100);
665     info2.SetCapacity(50);
666     ASSERT_FALSE(info1 == info2);
667 
668     info1 = info2 = g_info;
669     info2.SetVoltage(10);
670     info1.SetVoltage(5);
671     ASSERT_FALSE(info1 == info2);
672 
673     info1 = info2 = g_info;
674     info2.SetTemperature(5);
675     info1.SetTemperature(10);
676     ASSERT_FALSE(info1 == info2);
677 
678     info1 = info2 = g_info;
679     info2.SetHealthState(BatteryHealthState::HEALTH_STATE_GOOD);
680     info1.SetHealthState(BatteryHealthState::HEALTH_STATE_DEAD);
681     ASSERT_FALSE(info1 == info2);
682 
683     info1 = info2 = g_info;
684     info2.SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_USB);
685     info1.SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_NONE);
686     ASSERT_FALSE(info1 == info2);
687 
688     info1 = info2 = g_info;
689     info2.SetPluggedMaxCurrent(10);
690     info1.SetPluggedMaxCurrent(20);
691     ASSERT_FALSE(info1 == info2);
692     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient019 end.");
693 }
694 
695 /**
696  * @tc.name: BatteryClient020
697  * @tc.desc: Test ResetProxy
698  * @tc.type: FUNC
699  */
700 HWTEST_F(BatteryClientTest, BatteryClient020, TestSize.Level1)
701 {
702     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient020 start.");
703     auto& BatterySrvClient = BatterySrvClient::GetInstance();
704     BatterySrvClient.proxy_ = nullptr;
705     BatterySrvClient.ResetProxy(nullptr);
706 
707     sptr<ISystemAbilityManager> sysMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
708     if (sysMgr == nullptr) {
709         BATTERY_HILOGD(LABEL_TEST, "Failed to get Registry");
710         return;
711     }
712     wptr<IRemoteObject> remoteObj = sysMgr->CheckSystemAbility(POWER_MANAGER_SERVICE_ID);
713     if (remoteObj == nullptr) {
714         BATTERY_HILOGD(LABEL_TEST, "GetSystemAbility failed");
715         return;
716     }
717     EXPECT_NE(BatterySrvClient.Connect(), nullptr);
718     BatterySrvClient.ResetProxy(remoteObj);
719     EXPECT_NE(BatterySrvClient.proxy_, nullptr);
720 
721     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient020 end.");
722 }
723 
724 /**
725  * @tc.name: BatteryClient021
726  * @tc.desc: Test IBatterySrv interface SetBatteryConfig
727  * @tc.type: FUNC
728  */
729 HWTEST_F (BatteryClientTest, BatteryClient021, TestSize.Level1)
730 {
731     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient021 start.");
732     auto& BatterySrvClient = BatterySrvClient::GetInstance();
733 
734     string sceneName = "testScene";
735     string value = "";
736     int ret = (int)BatterySrvClient.SetBatteryConfig(sceneName, value);
737     EXPECT_NE(ret, 0);
738 
739     sceneName = "wireless";
740     ret = (int)BatterySrvClient.GetBatteryConfig(sceneName, value);
741     if (!value.empty()) {
742         ret = (int)BatterySrvClient.SetBatteryConfig(sceneName, value);
743         EXPECT_EQ(ret, 0);
744     }
745     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient021 end.");
746 }
747 
748 /**
749  * @tc.name: BatteryClient022
750  * @tc.desc: Test IBatterySrv interface GetBatteryConfig
751  * @tc.type: FUNC
752  */
753 HWTEST_F (BatteryClientTest, BatteryClient022, TestSize.Level1)
754 {
755     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient022 start.");
756     auto& BatterySrvClient = BatterySrvClient::GetInstance();
757 
758     string sceneName = "testScene";
759     string result = "";
760     BatteryError ret = BatterySrvClient.GetBatteryConfig(sceneName, result);
761     EXPECT_NE(ret, BatteryError::ERR_OK);
762     EXPECT_EQ(result, "");
763     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient022 end.");
764 }
765 
766 /**
767  * @tc.name: BatteryClient023
768  * @tc.desc: Test IBatterySrv interface IsBatteryConfigSupported
769  * @tc.type: FUNC
770  */
771 HWTEST_F (BatteryClientTest, BatteryClient023, TestSize.Level1)
772 {
773     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient023 start.");
774     auto& BatterySrvClient = BatterySrvClient::GetInstance();
775 
776     string sceneName = "testScene1";
777     bool result = false;
778     BatteryError ret = BatterySrvClient.IsBatteryConfigSupported(sceneName, result);
779     EXPECT_NE(ret, BatteryError::ERR_OK);
780     EXPECT_FALSE(result);
781     BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient023 end.");
782 }
783 
784 } // namespace
785