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