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_sttest.h"
17 
18 #include <csignal>
19 #include <iostream>
20 #include <fstream>
21 #include <memory>
22 #include <mutex>
23 #include <streambuf>
24 #include <cstring>
25 #include <thread>
26 #include <vector>
27 #include <sys/stat.h>
28 #include <fcntl.h>
29 #include <sys/types.h>
30 #include <dirent.h>
31 
32 #include "battery_log.h"
33 #include "battery_srv_client.h"
34 
35 using namespace testing::ext;
36 using namespace OHOS;
37 using namespace OHOS::PowerMgr;
38 using namespace std;
39 
40 namespace {
41 const std::string MOCK_BATTERY_PATH = "/data/service/el0/battery/";
42 bool g_isMock = false;
43 }
44 
SetUpTestCase(void)45 void BatterySttest::SetUpTestCase(void)
46 {
47     g_isMock = TestUtils::IsMock();
48     GTEST_LOG_(INFO) << " g_isMock: " << g_isMock;
49 }
50 
TearDownTestCase(void)51 void BatterySttest::TearDownTestCase(void)
52 {
53     g_isMock = false;
54     TestUtils::ResetOnline();
55 }
56 
57 namespace {
58 /**
59  * @tc.name: BatteryST001
60  * @tc.desc: Test IBatterySrv interface GetCapacity
61  * @tc.type: FUNC
62  * @tc.require: issueI6KRS8
63  */
HWTEST_F(BatterySttest, BatteryST001, TestSize.Level1)64 HWTEST_F (BatterySttest, BatteryST001, TestSize.Level1)
65 {
66     BATTERY_HILOGI(LABEL_TEST, "BatteryST001 start.");
67     auto& BatterySrvClient = BatterySrvClient::GetInstance();
68     if (g_isMock) {
69         BATTERY_HILOGI(LABEL_TEST, "BatteryST001 g_isMock 1.");
70         auto tempCapacity = BatterySrvClient.GetCapacity();
71         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "44");
72         auto capacity = BatterySrvClient.GetCapacity();
73         BATTERY_HILOGI(LABEL_TEST, "BatteryST001::capacity=%{public}d.", capacity);
74         GTEST_LOG_(INFO) << "BatteryST001 executing, capacity=" << capacity;
75         EXPECT_TRUE(capacity == 44);
76 
77         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", std::to_string(tempCapacity));
78         GTEST_LOG_(INFO) << "BatteryST001 executing, capacity=" << tempCapacity;
79     } else {
80         auto capacity = BatterySrvClient.GetCapacity();
81         BATTERY_HILOGI(LABEL_TEST, "BatteryST001::capacity=%{public}d", capacity);
82         GTEST_LOG_(INFO) << "BatteryST001 executing, capacity=" << capacity;
83         EXPECT_TRUE(capacity <= 100 && capacity >= 0);
84     }
85     BATTERY_HILOGI(LABEL_TEST, "BatteryST001 end.");
86 }
87 
88 /**
89  * @tc.name: BatteryST002
90  * @tc.desc: Test IBatterySrv interface GetChargingStatus when chargestate value is none
91  * @tc.type: FUNC
92  * @tc.require: issueI6KRS8
93  */
HWTEST_F(BatterySttest, BatteryST002, TestSize.Level1)94 HWTEST_F (BatterySttest, BatteryST002, TestSize.Level1)
95 {
96     BATTERY_HILOGI(LABEL_TEST, "BatteryST002 start.");
97     auto& BatterySrvClient = BatterySrvClient::GetInstance();
98     if (g_isMock) {
99         BATTERY_HILOGI(LABEL_TEST, "BatteryST002 g_isMock 1.");
100         auto tempChargeState = BatterySrvClient.GetChargingStatus();
101         std::string chargeStateArr[] = {"Discharging", "Charging", "Not charging", "Full", "Unknown"};
102 
103         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status", "Discharging");
104         auto chargeState = BatterySrvClient.GetChargingStatus();
105         BATTERY_HILOGI(LABEL_TEST, "BatteryST002::capacity=%{public}d.", chargeState);
106         GTEST_LOG_(INFO) << "BatteryST002 executing, chargeState=" << static_cast<int32_t>(chargeState);
107 
108         EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_NONE);
109         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status",
110                 chargeStateArr[static_cast<int32_t>(tempChargeState)]);
111         GTEST_LOG_(INFO) << "BatteryST002 executing, chargeState=" << static_cast<int32_t>(tempChargeState);
112     } else {
113         auto chargeState = BatterySrvClient.GetChargingStatus();
114         BATTERY_HILOGI(LABEL_TEST, "BatteryST002::chargeState=%{public}d",
115             static_cast<int32_t>(chargeState));
116         GTEST_LOG_(INFO) << "BatteryST002 executing, chargeState="
117             << static_cast<int32_t>(chargeState);
118         EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_ENABLE ||
119             chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_FULL);
120     }
121     BATTERY_HILOGI(LABEL_TEST, "BatteryST002 end.");
122 }
123 
124 /**
125  * @tc.name: BatteryST003
126  * @tc.desc: Test IBatterySrv interface GetChargingStatus when chargestate value is enable
127  * @tc.type: FUNC
128  * @tc.require: issueI6KRS8
129  */
HWTEST_F(BatterySttest, BatteryST003, TestSize.Level1)130 HWTEST_F (BatterySttest, BatteryST003, TestSize.Level1)
131 {
132     BATTERY_HILOGI(LABEL_TEST, "BatteryST003 start.");
133     auto& BatterySrvClient = BatterySrvClient::GetInstance();
134     if (g_isMock) {
135         BATTERY_HILOGI(LABEL_TEST, "BatteryST003 g_isMock 1.");
136         auto tempChargeState = BatterySrvClient.GetChargingStatus();
137         std::string chargeStateArr[] = {"Discharging", "Charging", "Not charging", "Full", "Unknown"};
138 
139         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status", "Charging");
140         auto chargeState = BatterySrvClient.GetChargingStatus();
141         GTEST_LOG_(INFO) << "BatteryST003 executing, chargeState=" << static_cast<int32_t>(chargeState);
142 
143         EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_ENABLE);
144         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status",
145                 chargeStateArr[static_cast<int32_t>(tempChargeState)]);
146         GTEST_LOG_(INFO) << "BatteryST003 executing, chargeState=" << static_cast<int32_t>(tempChargeState);
147     } else {
148         auto chargeState = BatterySrvClient.GetChargingStatus();
149         BATTERY_HILOGI(LABEL_TEST, "BatteryST003::chargeState=%{public}d",
150             static_cast<int32_t>(chargeState));
151         GTEST_LOG_(INFO) << "BatteryST003 executing, chargeState="
152             << static_cast<int32_t>(chargeState);
153         EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_ENABLE ||
154             chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_FULL);
155     }
156     BATTERY_HILOGI(LABEL_TEST, "BatteryST003 end.");
157 }
158 
159 /**
160  * @tc.name: BatteryST004
161  * @tc.desc: Test IBatterySrv interface GetChargingStatus when chargestate value is full
162  * @tc.type: FUNC
163  * @tc.require: issueI6KRS8
164  */
HWTEST_F(BatterySttest, BatteryST004, TestSize.Level1)165 HWTEST_F (BatterySttest, BatteryST004, TestSize.Level1)
166 {
167     BATTERY_HILOGI(LABEL_TEST, "enter. BatteryST004 start.");
168     auto& BatterySrvClient = BatterySrvClient::GetInstance();
169     if (g_isMock) {
170         BATTERY_HILOGI(LABEL_TEST, "BatteryST004 g_isMock 1.");
171         auto tempChargeState = BatterySrvClient.GetChargingStatus();
172         std::string chargeStateArr[] = {"Discharging", "Charging", "Not charging", "Full", "Unknown"};
173 
174         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status", "Full");
175         auto chargeState = BatterySrvClient.GetChargingStatus();
176         GTEST_LOG_(INFO) << "BatteryST004 executing, chargeState=" << static_cast<int32_t>(chargeState);
177 
178         EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_FULL);
179         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status",
180                 chargeStateArr[static_cast<int32_t>(tempChargeState)]);
181         GTEST_LOG_(INFO) << "BatteryST004 executing, chargeState=" << static_cast<int32_t>(tempChargeState);
182     } else {
183         auto chargeState = BatterySrvClient.GetChargingStatus();
184         BATTERY_HILOGI(LABEL_TEST, "BatteryST004::chargeState=%{public}d",
185             static_cast<int32_t>(chargeState));
186         GTEST_LOG_(INFO) << "BatteryST004 executing, chargeState="
187             << static_cast<int32_t>(chargeState);
188         EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_ENABLE ||
189             chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_FULL);
190     }
191     BATTERY_HILOGI(LABEL_TEST, "BatteryST004 end.");
192 }
193 
194 /**
195  * @tc.name: BatteryST005
196  * @tc.desc: Test IBatterySrv interface GetChargingStatus when chargestate value is disable
197  * @tc.type: FUNC
198  * @tc.require: issueI6KRS8
199  */
HWTEST_F(BatterySttest, BatteryST005, TestSize.Level1)200 HWTEST_F (BatterySttest, BatteryST005, TestSize.Level1)
201 {
202     BATTERY_HILOGI(LABEL_TEST, "BatteryST005 start.");
203     auto& BatterySrvClient = BatterySrvClient::GetInstance();
204     if (g_isMock) {
205         BATTERY_HILOGI(LABEL_TEST, "BatteryST005 g_isMock 1.");
206         auto tempChargeState = BatterySrvClient.GetChargingStatus();
207         std::string chargeStateArr[] = {"Discharging", "Charging", "Not charging", "Full", "Unknown"};
208 
209         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status", "Not charging");
210         auto chargeState = BatterySrvClient.GetChargingStatus();
211         GTEST_LOG_(INFO) << "BatteryST005 executing, chargeState=" << static_cast<int32_t>(chargeState);
212 
213         EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_DISABLE);
214         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status",
215                 chargeStateArr[static_cast<int32_t>(tempChargeState)]);
216         GTEST_LOG_(INFO) << "BatteryST005 executing, chargeState=" << static_cast<int32_t>(tempChargeState);
217     } else {
218         auto chargeState = BatterySrvClient.GetChargingStatus();
219         BATTERY_HILOGI(LABEL_TEST, "BatteryST005::chargeState=%{public}d",
220             static_cast<int32_t>(chargeState));
221         GTEST_LOG_(INFO) << "BatteryST005 executing, chargeState="
222             << static_cast<int32_t>(chargeState);
223         EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_ENABLE ||
224             chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_FULL);
225     }
226     BATTERY_HILOGI(LABEL_TEST, "BatteryST005 end.");
227 }
228 
229 /**
230  * @tc.name: BatteryST006
231  * @tc.desc: Test IBatterySrv interface GetChargingStatus when chargestate value is butt
232  * @tc.type: FUNC
233  * @tc.require: issueI6KRS8
234  */
HWTEST_F(BatterySttest, BatteryST006, TestSize.Level1)235 HWTEST_F (BatterySttest, BatteryST006, TestSize.Level1)
236 {
237     BATTERY_HILOGI(LABEL_TEST, "BatteryST006 start.");
238     auto& BatterySrvClient = BatterySrvClient::GetInstance();
239     if (g_isMock) {
240         BATTERY_HILOGI(LABEL_TEST, "BatteryST006 g_isMock 1.");
241         auto tempChargeState = BatterySrvClient.GetChargingStatus();
242         std::string chargeStateArr[] = {"Discharging", "Charging", "Not charging", "Full", "Unknown"};
243 
244         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status", "Unknown");
245         auto chargeState = BatterySrvClient.GetChargingStatus();
246         GTEST_LOG_(INFO) << "BatteryST006 executing, chargeState=" << static_cast<int32_t>(chargeState);
247 
248         EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_BUTT);
249         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status",
250                 chargeStateArr[static_cast<int32_t>(tempChargeState)]);
251         GTEST_LOG_(INFO) << "BatteryST006 executing, chargeState=" << static_cast<int32_t>(tempChargeState);
252     } else {
253         auto chargeState = BatterySrvClient.GetChargingStatus();
254         BATTERY_HILOGI(LABEL_TEST, "BatteryST006::chargeState=%{public}d",
255             static_cast<int32_t>(chargeState));
256         GTEST_LOG_(INFO) << "BatteryST006 executing, chargeState="
257             << static_cast<int32_t>(chargeState);
258         EXPECT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_ENABLE ||
259             chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_FULL);
260     }
261     BATTERY_HILOGI(LABEL_TEST, "BatteryST006 end.");
262 }
263 
264 /**
265  * @tc.name: BatteryST007
266  * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_GOOD
267  * @tc.type: FUNC
268  * @tc.require: issueI6KRS8
269  */
HWTEST_F(BatterySttest, BatteryST007, TestSize.Level1)270 HWTEST_F (BatterySttest, BatteryST007, TestSize.Level1)
271 {
272     BATTERY_HILOGI(LABEL_TEST, "BatteryST007 start.");
273     auto& BatterySrvClient = BatterySrvClient::GetInstance();
274     if (g_isMock) {
275         BATTERY_HILOGI(LABEL_TEST, "BatteryST007 g_isMock 1.");
276         auto tempHealthState = BatterySrvClient.GetHealthStatus();
277         std::string healthStateArr[] = {"Unknown", "Good", "Hot", "Over voltage", "Cold", "Dead"};
278 
279         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health", "Good");
280         auto healthState = BatterySrvClient.GetHealthStatus();
281         GTEST_LOG_(INFO) << "BatteryST007 executing, healthState=" << static_cast<int32_t>(healthState);
282 
283         EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
284         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health",
285                 healthStateArr[static_cast<int32_t>(tempHealthState)]);
286         GTEST_LOG_(INFO) << "BatteryST007 executing, healthState=" << static_cast<int32_t>(tempHealthState);
287     } else {
288         auto healthState = BatterySrvClient.GetHealthStatus();
289         BATTERY_HILOGI(LABEL_TEST, "BatteryST007::healthState=%{public}d",
290             static_cast<int32_t>(healthState));
291         GTEST_LOG_(INFO) << "BatteryST007 executing, healthState="
292             << static_cast<int32_t>(healthState);
293         EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
294     }
295     BATTERY_HILOGI(LABEL_TEST, "BatteryST007 end.");
296 }
297 
298 /**
299  * @tc.name: BatteryST008
300  * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_COLD
301  * @tc.type: FUNC
302  * @tc.require: issueI6KRS8
303  */
HWTEST_F(BatterySttest, BatteryST008, TestSize.Level1)304 HWTEST_F (BatterySttest, BatteryST008, TestSize.Level1)
305 {
306     BATTERY_HILOGI(LABEL_TEST, "BatteryST008 start.");
307     auto& BatterySrvClient = BatterySrvClient::GetInstance();
308     if (g_isMock) {
309         BATTERY_HILOGI(LABEL_TEST, "BatteryST008 g_isMock 1.");
310         auto tempHealthState = BatterySrvClient.GetHealthStatus();
311         std::string healthStateArr[] = {"Unknown", "Good", "Hot", "Over voltage", "Cold", "Dead"};
312 
313         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health", "Cold");
314         auto healthState = BatterySrvClient.GetHealthStatus();
315         GTEST_LOG_(INFO) << "BatteryST008 executing, healthState=" << static_cast<int32_t>(healthState);
316 
317         EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_COLD);
318         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health",
319                 healthStateArr[static_cast<int32_t>(tempHealthState)]);
320         GTEST_LOG_(INFO) << "BatteryST008 executing, healthState=" << static_cast<int32_t>(tempHealthState);
321     } else {
322         auto healthState = BatterySrvClient.GetHealthStatus();
323         BATTERY_HILOGI(LABEL_TEST, "BatteryST008::healthState=%{public}d",
324             static_cast<int32_t>(healthState));
325         GTEST_LOG_(INFO) << "BatteryST008 executing, healthState="
326             << static_cast<int32_t>(healthState);
327         EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
328     }
329     BATTERY_HILOGI(LABEL_TEST, "BatteryST008 end.");
330 }
331 
332 /**
333  * @tc.name: BatteryST009
334  * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_OVERHEAT
335  * @tc.type: FUNC
336  * @tc.require: issueI6KRS8
337  */
HWTEST_F(BatterySttest, BatteryST009, TestSize.Level1)338 HWTEST_F (BatterySttest, BatteryST009, TestSize.Level1)
339 {
340     BATTERY_HILOGI(LABEL_TEST, "BatteryST009 start.");
341     auto& BatterySrvClient = BatterySrvClient::GetInstance();
342     if (g_isMock) {
343         BATTERY_HILOGI(LABEL_TEST, "BatteryST009 g_isMock 1.");
344         auto tempHealthState = BatterySrvClient.GetHealthStatus();
345         std::string healthStateArr[] = {"Unknown", "Good", "Hot", "Over voltage", "Cold", "Dead"};
346 
347         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health", "Hot");
348         auto healthState = BatterySrvClient.GetHealthStatus();
349         GTEST_LOG_(INFO) << "BatteryST009 executing, healthState=" << static_cast<int32_t>(healthState);
350 
351         EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_OVERHEAT);
352         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health",
353                 healthStateArr[static_cast<int32_t>(tempHealthState)]);
354         GTEST_LOG_(INFO) << "BatteryST009 executing, healthState=" << static_cast<int32_t>(tempHealthState);
355     } else {
356         auto healthState = BatterySrvClient.GetHealthStatus();
357         BATTERY_HILOGI(LABEL_TEST, "BatteryST009::healthState=%{public}d",
358             static_cast<int32_t>(healthState));
359         GTEST_LOG_(INFO) << "BatteryST009 executing, healthState="
360             << static_cast<int32_t>(healthState);
361         EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
362     }
363     BATTERY_HILOGI(LABEL_TEST, "BatteryST009 end.");
364 }
365 
366 /**
367  * @tc.name: BatteryST010
368  * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_OVERVOLTAGE
369  * @tc.type: FUNC
370  * @tc.require: issueI6KRS8
371  */
HWTEST_F(BatterySttest, BatteryST010, TestSize.Level1)372 HWTEST_F (BatterySttest, BatteryST010, TestSize.Level1)
373 {
374     BATTERY_HILOGI(LABEL_TEST, "BatteryST010 start.");
375     auto& BatterySrvClient = BatterySrvClient::GetInstance();
376     if (g_isMock) {
377         BATTERY_HILOGI(LABEL_TEST, "BatteryST010 g_isMock 1.");
378         auto tempHealthState = BatterySrvClient.GetHealthStatus();
379         std::string healthStateArr[] = {"Unknown", "Good", "Hot", "Over voltage", "Cold", "Dead"};
380 
381         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health", "Over voltage");
382         auto healthState = BatterySrvClient.GetHealthStatus();
383         GTEST_LOG_(INFO) << "BatteryST010 executing, healthState=" << static_cast<int32_t>(healthState);
384 
385         EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_OVERVOLTAGE);
386         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health",
387                 healthStateArr[static_cast<int32_t>(tempHealthState)]);
388         GTEST_LOG_(INFO) << "BatteryST010 executing, healthState=" << static_cast<int32_t>(tempHealthState);
389     } else {
390         auto healthState = BatterySrvClient.GetHealthStatus();
391         BATTERY_HILOGI(LABEL_TEST, "BatteryST010::healthState=%{public}d",
392             static_cast<int32_t>(healthState));
393         GTEST_LOG_(INFO) << "BatteryST010 executing, healthState="
394             << static_cast<int32_t>(healthState);
395         EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
396     }
397     BATTERY_HILOGI(LABEL_TEST, "BatteryST010 end.");
398 }
399 
400 /**
401  * @tc.name: BatteryST011
402  * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_DEAD
403  * @tc.type: FUNC
404  * @tc.require: issueI6KRS8
405  */
HWTEST_F(BatterySttest, BatteryST011, TestSize.Level1)406 HWTEST_F (BatterySttest, BatteryST011, TestSize.Level1)
407 {
408     BATTERY_HILOGI(LABEL_TEST, "BatteryST011 start.");
409     auto& BatterySrvClient = BatterySrvClient::GetInstance();
410     if (g_isMock) {
411         BATTERY_HILOGI(LABEL_TEST, "BatteryST011 g_isMock 1.");
412         auto tempHealthState = BatterySrvClient.GetHealthStatus();
413         std::string healthStateArr[] = {"Unknown", "Good", "Hot", "Over voltage", "Cold", "Dead"};
414 
415         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health", "Dead");
416         auto healthState = BatterySrvClient.GetHealthStatus();
417         GTEST_LOG_(INFO) << "BatteryST011 executing, healthState=" << static_cast<int32_t>(healthState);
418 
419         EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_DEAD);
420         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health",
421                 healthStateArr[static_cast<int32_t>(tempHealthState)]);
422         GTEST_LOG_(INFO) << "BatteryST011 executing, healthState=" << static_cast<int32_t>(tempHealthState);
423     } else {
424         auto healthState = BatterySrvClient.GetHealthStatus();
425         BATTERY_HILOGI(LABEL_TEST, "BatteryST011::healthState=%{public}d",
426             static_cast<int32_t>(healthState));
427         GTEST_LOG_(INFO) << "BatteryST011 executing, healthState="
428             << static_cast<int32_t>(healthState);
429         EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
430     }
431     BATTERY_HILOGI(LABEL_TEST, "BatteryST011 end.");
432 }
433 
434 /**
435  * @tc.name: BatteryST012
436  * @tc.desc: Test IBatterySrv interface GetHealthStatus when healthstatus value is HEALTH_STATE_UNKNOWN
437  * @tc.type: FUNC
438  * @tc.require: issueI6KRS8
439  */
HWTEST_F(BatterySttest, BatteryST012, TestSize.Level1)440 HWTEST_F (BatterySttest, BatteryST012, TestSize.Level1)
441 {
442     BATTERY_HILOGI(LABEL_TEST, "BatteryST012 start.");
443     auto& BatterySrvClient = BatterySrvClient::GetInstance();
444     if (g_isMock) {
445         BATTERY_HILOGI(LABEL_TEST, "BatteryST012 g_isMock 1.");
446         auto tempHealthState = BatterySrvClient.GetHealthStatus();
447         std::string healthStateArr[] = {"Unknown", "Good", "Hot", "Over voltage", "Cold", "Dead"};
448 
449         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health", "Unknown");
450         auto healthState = BatterySrvClient.GetHealthStatus();
451         GTEST_LOG_(INFO) << "BatteryST012 executing, healthState=" << static_cast<int32_t>(healthState);
452 
453         EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_UNKNOWN);
454         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health",
455                 healthStateArr[static_cast<int32_t>(tempHealthState)]);
456         GTEST_LOG_(INFO) << "BatteryST012 executing, healthState=" << static_cast<int32_t>(tempHealthState);
457     } else {
458         auto healthState = BatterySrvClient.GetHealthStatus();
459         BATTERY_HILOGI(LABEL_TEST, "BatteryST012::healthState=%{public}d",
460             static_cast<int32_t>(healthState));
461         GTEST_LOG_(INFO) << "BatteryST012 executing, healthState="
462             << static_cast<int32_t>(healthState);
463         EXPECT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
464     }
465     BATTERY_HILOGI(LABEL_TEST, "BatteryST012 end.");
466 }
467 
468 /**
469  * @tc.name: BatteryST013
470  * @tc.desc: Test IBatterySrv interface GetPresent when present is true
471  * @tc.type: FUNC
472  * @tc.require: issueI6KRS8
473  */
HWTEST_F(BatterySttest, BatteryST013, TestSize.Level1)474 HWTEST_F (BatterySttest, BatteryST013, TestSize.Level1)
475 {
476     BATTERY_HILOGI(LABEL_TEST, "BatteryST013 start.");
477     auto& BatterySrvClient = BatterySrvClient::GetInstance();
478     if (g_isMock) {
479         BATTERY_HILOGI(LABEL_TEST, "BatteryST012 g_isMock 1.");
480         auto tempPresent = BatterySrvClient.GetPresent();
481 
482         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", "1");
483         auto present = BatterySrvClient.GetPresent();
484         GTEST_LOG_(INFO) << "BatteryST013 executing, present=" << present;
485 
486         EXPECT_TRUE(present);
487         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", std::to_string(tempPresent));
488         GTEST_LOG_(INFO) << "BatteryST013 executing, tempPresent=" << static_cast<int32_t>(tempPresent);
489     } else {
490         auto present = BatterySrvClient.GetPresent();
491         BATTERY_HILOGI(LABEL_TEST, "BatteryST013::present=%{public}d", present);
492         GTEST_LOG_(INFO) << "BatteryST013 executing, present=" << present;
493         EXPECT_TRUE(present);
494     }
495     BATTERY_HILOGI(LABEL_TEST, "BatteryST013 end.");
496 }
497 
498 /**
499  * @tc.name: BatteryST014
500  * @tc.desc: Test IBatterySrv interface GetPresent when present is false
501  * @tc.type: FUNC
502  * @tc.require: issueI6KRS8
503  */
HWTEST_F(BatterySttest, BatteryST014, TestSize.Level1)504 HWTEST_F (BatterySttest, BatteryST014, TestSize.Level1)
505 {
506     BATTERY_HILOGI(LABEL_TEST, "BatteryST014 start.");
507     auto& BatterySrvClient = BatterySrvClient::GetInstance();
508     if (g_isMock) {
509         BATTERY_HILOGI(LABEL_TEST, "BatteryST014 g_isMock 1.");
510         auto tempPresent = BatterySrvClient.GetPresent();
511 
512         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", "0");
513         auto present = BatterySrvClient.GetPresent();
514         GTEST_LOG_(INFO) << "BatteryST014 executing, present=" << present;
515 
516         EXPECT_FALSE(present);
517         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", std::to_string(tempPresent));
518         GTEST_LOG_(INFO) << "BatteryST014 executing, tempPresent=" << static_cast<int32_t>(tempPresent);
519     } else {
520         auto present = BatterySrvClient.GetPresent();
521         BATTERY_HILOGI(LABEL_TEST, "BatteryST014::present=%{public}d", present);
522         GTEST_LOG_(INFO) << "BatteryST014 executing, present=" << present;
523         EXPECT_TRUE(present);
524     }
525     BATTERY_HILOGI(LABEL_TEST, "BatteryST014 end.");
526 }
527 
528 /**
529  * @tc.name: BatteryST015
530  * @tc.desc: Test IBatterySrv interface GetVoltage
531  * @tc.type: FUNC
532  * @tc.require: issueI6KRS8
533  */
HWTEST_F(BatterySttest, BatteryST015, TestSize.Level1)534 HWTEST_F (BatterySttest, BatteryST015, TestSize.Level1)
535 {
536     BATTERY_HILOGI(LABEL_TEST, "BatteryST015 start.");
537     auto& BatterySrvClient = BatterySrvClient::GetInstance();
538     if (g_isMock) {
539         BATTERY_HILOGI(LABEL_TEST, "BatteryST015 g_isMock 1.");
540         auto tempVoltagenow = BatterySrvClient.GetVoltage();
541 
542         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", "4654321");
543         auto voltage = BatterySrvClient.GetVoltage();
544         GTEST_LOG_(INFO) << "BatteryST015 executing, voltage=" << voltage;
545 
546         EXPECT_TRUE(voltage == 4654321);
547         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", std::to_string(tempVoltagenow));
548         GTEST_LOG_(INFO) << "BatteryST015 executing, tempPresent=" << static_cast<int32_t>(tempVoltagenow);
549     } else {
550         auto voltage = BatterySrvClient.GetVoltage();
551         BATTERY_HILOGI(LABEL_TEST, "BatteryST015::voltage=%{public}d", voltage);
552         GTEST_LOG_(INFO) << "BatteryST015 executing, voltage=" << voltage;
553         EXPECT_TRUE(voltage >= 0);
554     }
555     BATTERY_HILOGI(LABEL_TEST, "BatteryST015 end.");
556 }
557 
558 /**
559  * @tc.name: BatteryST016
560  * @tc.desc: Test IBatterySrv interface GetTemperature
561  * @tc.type: FUNC
562  * @tc.require: issueI6KRS8
563  */
HWTEST_F(BatterySttest, BatteryST016, TestSize.Level1)564 HWTEST_F (BatterySttest, BatteryST016, TestSize.Level1)
565 {
566     BATTERY_HILOGI(LABEL_TEST, "BatteryST016 start.");
567     auto& BatterySrvClient = BatterySrvClient::GetInstance();
568     if (g_isMock) {
569         BATTERY_HILOGI(LABEL_TEST, "BatteryST016 g_isMock 1.");
570         auto tempTempPresent = BatterySrvClient.GetBatteryTemperature();
571 
572         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", "234");
573         auto temperature = BatterySrvClient.GetBatteryTemperature();
574         GTEST_LOG_(INFO) << "BatteryST016 executing, temperature=" << temperature;
575 
576         EXPECT_TRUE(temperature == 234);
577         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", std::to_string(tempTempPresent));
578         GTEST_LOG_(INFO) << "BatteryST016 executing, temperature=" << static_cast<int32_t>(tempTempPresent);
579     } else {
580         auto temperature = BatterySrvClient.GetBatteryTemperature();
581         BATTERY_HILOGI(LABEL_TEST, "BatteryST016::temperature=%{public}d", temperature);
582         GTEST_LOG_(INFO) << "BatteryST016 executing, temperature=" << temperature;
583         EXPECT_TRUE(temperature >= 0 && temperature <= 600);
584     }
585     BATTERY_HILOGI(LABEL_TEST, "BatteryST016 end.");
586 }
587 
588 /**
589  * @tc.name: BatteryST017
590  * @tc.desc: Test IBatterySrv interface GetTechnology
591  * @tc.type: FUNC
592  * @tc.require: issueI6KRS8
593  */
HWTEST_F(BatterySttest, BatteryST017, TestSize.Level1)594 HWTEST_F (BatterySttest, BatteryST017, TestSize.Level1)
595 {
596     BATTERY_HILOGI(LABEL_TEST, "BatteryST017 start.");
597     auto& BatterySrvClient = BatterySrvClient::GetInstance();
598     if (g_isMock) {
599         BATTERY_HILOGI(LABEL_TEST, "BatteryST017 g_isMock 1.");
600         std::string tempTechnology = BatterySrvClient.GetTechnology();
601 
602         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos-fgu/technology", "H2");
603         auto technology = BatterySrvClient.GetTechnology();
604         GTEST_LOG_(INFO) << "BatteryST017 executing, technology=" << technology;
605 
606         EXPECT_TRUE(technology == "H2");
607         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos-fgu/technology", tempTechnology);
608         GTEST_LOG_(INFO) << "BatteryST017 executing, technology=" << tempTechnology;
609     } else {
610         auto technology = BatterySrvClient.GetTechnology();
611         BATTERY_HILOGI(LABEL_TEST, "BatteryST017::technology=%{public}s", technology.c_str());
612         GTEST_LOG_(INFO) << "BatteryST017 executing, technology=" << technology;
613         EXPECT_TRUE(technology == "Li-poly");
614     }
615     BATTERY_HILOGI(LABEL_TEST, "BatteryST058 end.");
616 }
617 
618 /**
619  * @tc.name: BatteryST018
620  * @tc.desc: Test IBatterySrv interface GetPluggedType when pluggedType value is PLUGGED_TYPE_AC
621  * @tc.type: FUNC
622  * @tc.require: issueI6KRS8
623  */
HWTEST_F(BatterySttest, BatteryST018, TestSize.Level1)624 HWTEST_F (BatterySttest, BatteryST018, TestSize.Level1)
625 {
626     BATTERY_HILOGI(LABEL_TEST, "BatteryST018 start.");
627     auto& BatterySrvClient = BatterySrvClient::GetInstance();
628     if (g_isMock) {
629         BATTERY_HILOGI(LABEL_TEST, "BatteryST018 g_isMock 1.");
630         TestUtils::ResetOnline();
631         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/online", "1");
632         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/type", "Mains");
633 
634         auto pluggedType = BatterySrvClient.GetPluggedType();
635         GTEST_LOG_(INFO) << "BatteryST018 executing, pluggedType=" << static_cast<int32_t>(pluggedType);
636 
637         EXPECT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_AC);
638     } else {
639         auto pluggedType = BatterySrvClient.GetPluggedType();
640         BATTERY_HILOGI(LABEL_TEST, "BatteryST018::pluggedType=%{public}d",
641             static_cast<int32_t>(pluggedType));
642         GTEST_LOG_(INFO) << "BatteryST018 executing, pluggedType="
643             << static_cast<int32_t>(pluggedType);
644         EXPECT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_USB);
645     }
646     BATTERY_HILOGI(LABEL_TEST, "BatteryST018 end.");
647 }
648 
649 /**
650  * @tc.name: BatteryST019
651  * @tc.desc: Test IBatterySrv interface GetPluggedType when pluggedType value is PLUGGED_TYPE_USB
652  * @tc.type: FUNC
653  * @tc.require: issueI6KRS8
654  */
HWTEST_F(BatterySttest, BatteryST019, TestSize.Level1)655 HWTEST_F (BatterySttest, BatteryST019, TestSize.Level1)
656 {
657     BATTERY_HILOGI(LABEL_TEST, "BatteryST019 start.");
658     auto& BatterySrvClient = BatterySrvClient::GetInstance();
659     if (g_isMock) {
660         BATTERY_HILOGI(LABEL_TEST, "BatteryST019 g_isMock 1.");
661         TestUtils::ResetOnline();
662         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/online", "1");
663         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/type", "USB");
664 
665         auto pluggedType = BatterySrvClient.GetPluggedType();
666         GTEST_LOG_(INFO) << "BatteryST019 executing, pluggedType=" << static_cast<int32_t>(pluggedType);
667 
668         EXPECT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_USB);
669     } else {
670         auto pluggedType = BatterySrvClient.GetPluggedType();
671         BATTERY_HILOGI(LABEL_TEST, "BatteryST019::pluggedType=%{public}d",
672             static_cast<int32_t>(pluggedType));
673         GTEST_LOG_(INFO) << "BatteryST019 executing, pluggedType="
674             << static_cast<int32_t>(pluggedType);
675         EXPECT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_USB);
676     }
677     BATTERY_HILOGI(LABEL_TEST, "BatteryST019 end.");
678 }
679 
680 /**
681  * @tc.name: BatteryST020
682  * @tc.desc: Test IBatterySrv interface GetPluggedType when pluggedType value is PLUGGED_TYPE_WIRELESS
683  * @tc.type: FUNC
684  * @tc.require: issueI6KRS8
685  */
HWTEST_F(BatterySttest, BatteryST020, TestSize.Level1)686 HWTEST_F (BatterySttest, BatteryST020, TestSize.Level1)
687 {
688     BATTERY_HILOGI(LABEL_TEST, "BatteryST020 start.");
689     auto& BatterySrvClient = BatterySrvClient::GetInstance();
690     if (g_isMock) {
691         BATTERY_HILOGI(LABEL_TEST, "BatteryST020 g_isMock 1.");
692         TestUtils::ResetOnline();
693         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/online", "1");
694         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/type", "Wireless");
695 
696         auto pluggedType = BatterySrvClient.GetPluggedType();
697         GTEST_LOG_(INFO) << "BatteryST020 executing, pluggedType=" << static_cast<int32_t>(pluggedType);
698 
699         EXPECT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_WIRELESS);
700     } else {
701         auto pluggedType = BatterySrvClient.GetPluggedType();
702         BATTERY_HILOGI(LABEL_TEST, "BatteryST020::pluggedType=%{public}d",
703             static_cast<int32_t>(pluggedType));
704         GTEST_LOG_(INFO) << "BatteryST020 executing, pluggedType="
705             << static_cast<int32_t>(pluggedType);
706         EXPECT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_USB);
707     }
708     BATTERY_HILOGI(LABEL_TEST, "BatteryST020 end.");
709 }
710 
711 /**
712  * @tc.name: BatteryST021
713  * @tc.desc: Test IBatterySrv interface GetPluggedType when pluggedType value is PLUGGED_TYPE_BUTT
714  *           ParsePluggedType return HDF_ERR_NOT_SUPPORT, g_service->GetPluggedType FAIL
715  * @tc.type: FUNC
716  * @tc.require: issueI6KRS8
717  */
HWTEST_F(BatterySttest, BatteryST021, TestSize.Level1)718 HWTEST_F (BatterySttest, BatteryST021, TestSize.Level1)
719 {
720     BATTERY_HILOGI(LABEL_TEST, "BatteryST021 start.");
721     auto& BatterySrvClient = BatterySrvClient::GetInstance();
722     if (g_isMock) {
723         BATTERY_HILOGI(LABEL_TEST, "BatteryST021 g_isMock 1.");
724         TestUtils::ResetOnline();
725         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/online", "1");
726         TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/type", "Unknown");
727 
728         auto pluggedType = BatterySrvClient.GetPluggedType();
729         GTEST_LOG_(INFO) << "BatteryST021 executing, pluggedType=" << static_cast<int32_t>(pluggedType);
730 
731         EXPECT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_NONE);
732     } else {
733         auto pluggedType = BatterySrvClient.GetPluggedType();
734         BATTERY_HILOGI(LABEL_TEST, "BatteryST021::pluggedType=%{public}d",
735             static_cast<int32_t>(pluggedType));
736         GTEST_LOG_(INFO) << "BatteryST021 executing, pluggedType="
737             << static_cast<int32_t>(pluggedType);
738         EXPECT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_USB);
739     }
740     BATTERY_HILOGI(LABEL_TEST, "BatteryST021 end.");
741 }
742 }
743