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