1 /*
2 * Copyright (c) 2022-2025 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_service_test.h"
17
18 #ifdef GTEST
19 #define private public
20 #define protected public
21 #endif
22
23 #include <fcntl.h>
24 #include <memory>
25 #include <string>
26
27 #include "battery_info.h"
28 #include "battery_log.h"
29 #include "battery_service.h"
30 #include "common_event_data.h"
31 #include "common_event_subscriber.h"
32 #include "common_event_support.h"
33 #include "securec.h"
34 #include "test_utils.h"
35 #include "battery_xcollie.h"
36
37 using namespace testing::ext;
38 using namespace OHOS::PowerMgr;
39 using namespace OHOS::EventFwk;
40 using namespace OHOS::HDI::Battery;
41 using namespace OHOS;
42 using namespace std;
43
44 namespace {
45 sptr<BatteryService> g_service;
46 bool g_isMock = TestUtils::IsMock();
47 const std::string MOCK_BATTERY_PATH = "/data/service/el0/battery/";
48 constexpr int DELAY_TIME_US = 200000;
49 constexpr int TEST_CAPACITY_MIN = 0;
50 constexpr int TEST_CAPACITY_MAX = 100;
51 constexpr int TEST_CAPACITY_FIRST = 50;
52 constexpr int TEST_CAPACITY_SECOND = 60;
53 }
54
TearDownTestCase(void)55 void BatteryServiceTest::TearDownTestCase(void)
56 {
57 g_service->Reset();
58 }
59
60 /**
61 * @tc.name: BatteryService000
62 * @tc.desc: Test functions DelayedSpSingleton GetInstance
63 * @tc.type: FUNC
64 * @tc.require: issueI5YZR1
65 */
66 static HWTEST_F(BatteryServiceTest, BatteryService000, TestSize.Level1)
67 {
68 BATTERY_HILOGI(LABEL_TEST, "BatteryService000 function start!");
69 g_service = DelayedSpSingleton<BatteryService>::GetInstance();
70 EXPECT_TRUE(g_service != nullptr);
71 g_service->OnStart();
72 g_service = nullptr;
73 g_service = DelayedSpSingleton<BatteryService>::GetInstance();
74 EXPECT_TRUE(g_service != nullptr);
75 BATTERY_HILOGI(LABEL_TEST, "BatteryService000 function end!");
76 }
77
78 /**
79 * @tc.name: BatteryService001
80 * @tc.desc: Test functions RegisterBatteryHdiCallback
81 * @tc.type: FUNC
82 * @tc.require: issueI5YZR1
83 */
84 static HWTEST_F(BatteryServiceTest, BatteryService001, TestSize.Level1)
85 {
86 BATTERY_HILOGI(LABEL_TEST, "BatteryService001 function start!");
87 EXPECT_TRUE(g_service->RegisterBatteryHdiCallback());
88 BATTERY_HILOGI(LABEL_TEST, "BatteryService001 function end!");
89 }
90
91 /**
92 * @tc.name: BatteryService004
93 * @tc.desc: Test functions GetVoltage
94 * @tc.type: FUNC
95 * @tc.require: issueI5YZR1
96 */
97 static HWTEST_F(BatteryServiceTest, BatteryService004, TestSize.Level1)
98 {
99 BATTERY_HILOGI(LABEL_TEST, "BatteryService004 function start!");
100 if (g_isMock) {
101 auto tempVoltage = g_service->GetVoltageInner();
102 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", "4654321");
103 auto voltage = g_service->GetVoltageInner();
104 EXPECT_TRUE(voltage == 4654321);
105 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", std::to_string(tempVoltage));
106 } else {
107 auto voltage = g_service->GetVoltageInner();
108 BATTERY_HILOGI(LABEL_TEST, "BatteryService004::voltage=%{public}d", voltage);
109 GTEST_LOG_(INFO) << "BatteryService004 executing, voltage=" << voltage;
110 EXPECT_TRUE(voltage >= 0);
111 }
112
113 BATTERY_HILOGI(LABEL_TEST, "BatteryService004 function end!");
114 }
115
116 /**
117 * @tc.name: BatteryService005
118 * @tc.desc: Test functions GetPresent
119 * @tc.type: FUNC
120 * @tc.require: issueI5YZR1
121 */
122 static HWTEST_F(BatteryServiceTest, BatteryService005, TestSize.Level1)
123 {
124 BATTERY_HILOGI(LABEL_TEST, "BatteryService005 function start!");
125 if (g_isMock) {
126 auto tempPresent = g_service->GetPresentInner();
127 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", "0");
128 auto present = g_service->GetPresentInner();
129 BATTERY_HILOGI(LABEL_TEST, "BatteryService005::present=%{public}d", present);
130 GTEST_LOG_(INFO) << "BatteryService005 executing, present=" << present;
131 EXPECT_FALSE(present);
132 auto presentIdl = false;
133 g_service->GetPresent(presentIdl);
134 EXPECT_EQ(present, presentIdl);
135 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", std::to_string(tempPresent));
136 } else {
137 auto present = g_service->GetPresentInner();
138 BATTERY_HILOGI(LABEL_TEST, "BatteryService005::present=%{public}d", present);
139 GTEST_LOG_(INFO) << "BatteryService005 executing, present=" << present;
140 EXPECT_TRUE(present);
141 auto presentIdl = false;
142 g_service->GetPresent(presentIdl);
143 EXPECT_EQ(present, presentIdl);
144 }
145 BATTERY_HILOGI(LABEL_TEST, "BatteryService005 function end!");
146 }
147
148 /**
149 * @tc.name: BatteryService006
150 * @tc.desc: Test functions GetBatteryTemperature
151 * @tc.type: FUNC
152 * @tc.require: issueI5YZR1
153 */
154 static HWTEST_F(BatteryServiceTest, BatteryService006, TestSize.Level1)
155 {
156 BATTERY_HILOGI(LABEL_TEST, "BatteryService006 function start!");
157 if (g_isMock) {
158 auto tempTempPresent = g_service->GetBatteryTemperatureInner();
159 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", "222");
160 auto temperature = g_service->GetBatteryTemperatureInner();
161 BATTERY_HILOGI(LABEL_TEST, "BatteryService006::temperature=%{public}d", temperature);
162 GTEST_LOG_(INFO) << "BatteryService006 executing, temperature=" << temperature;
163 EXPECT_TRUE(temperature == 222);
164 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", std::to_string(tempTempPresent));
165 } else {
166 auto temperature = g_service->GetBatteryTemperatureInner();
167 BATTERY_HILOGI(LABEL_TEST, "BatteryService006::temperature=%{public}d", temperature);
168 GTEST_LOG_(INFO) << "BatteryService006 executing, temperature=" << temperature;
169 EXPECT_TRUE(temperature >= 0 && temperature <= 600);
170 }
171 BATTERY_HILOGI(LABEL_TEST, "BatteryService006 function end!");
172 }
173
174 /**
175 * @tc.name: BatteryService012
176 * @tc.desc: Test functions RegisterHdiStatusListener
177 * @tc.type: FUNC
178 * @tc.require: issueI5YZR1
179 */
180 static HWTEST_F(BatteryServiceTest, BatteryService007, TestSize.Level1)
181 {
182 BATTERY_HILOGI(LABEL_TEST, "BatteryService007 function start!");
183 EXPECT_TRUE(g_service->RegisterHdiStatusListener());
184 BATTERY_HILOGI(LABEL_TEST, "BatteryService007 function end!");
185 }
186
187 /**
188 * @tc.name: BatteryService008
189 * @tc.desc: Test functions OnStart and OnStop and OnAddSystemAbility
190 * @tc.type: FUNC
191 * @tc.require: issueI5YZR1
192 */
193 static HWTEST_F(BatteryServiceTest, BatteryService008, TestSize.Level1)
194 {
195 BATTERY_HILOGI(LABEL_TEST, "BatteryService008 function start!");
196 g_service->OnStart();
197 g_service->OnStart();
198 g_service->OnStop();
199 g_service->OnStop();
200 int32_t systemAbilityId = 3602; // MISCDEVICE_SERVICE_ABILITY_ID
201 g_service->OnAddSystemAbility(systemAbilityId, std::string("BatteryService008"));
202 g_service->OnAddSystemAbility(0, std::string("BatteryService008"));
203 g_service->ready_ = true;
204 g_service->OnStart();
205 EXPECT_TRUE(g_service->ready_);
206 g_service->OnStop();
207 EXPECT_FALSE(g_service->ready_);
208
209 g_service->OnStart();
210 g_service->iBatteryInterface_ = V2_0::IBatteryInterface::Get();
211 BATTERY_HILOGI(LABEL_TEST, "BatteryService008 function end!");
212 }
213
214 /**
215 * @tc.name: BatteryService009
216 * @tc.desc: Test functions MockUnplugged
217 * @tc.type: FUNC
218 * @tc.require: issueI5YZR1
219 */
220 static HWTEST_F(BatteryServiceTest, BatteryService009, TestSize.Level1)
221 {
222 BATTERY_HILOGI(LABEL_TEST, "BatteryService009 function start!");
223 usleep(DELAY_TIME_US);
224 g_service->MockUnplugged();
225 EXPECT_EQ(g_service->IsMockUnplugged(), true);
226 BATTERY_HILOGI(LABEL_TEST, "BatteryService009 function end!");
227 }
228
229 /**
230 * @tc.name: BatteryService010
231 * @tc.desc: Test functions GetRemainEnergy
232 * @tc.type: FUNC
233 * @tc.require: issueI5YZR1
234 */
235 static HWTEST_F(BatteryServiceTest, BatteryService010, TestSize.Level1)
236 {
237 BATTERY_HILOGI(LABEL_TEST, "BatteryService010 function start!");
238 EXPECT_NE(g_service->GetRemainEnergyInner(), ERR_NO_INIT);
239 BATTERY_HILOGI(LABEL_TEST, "BatteryService010 function end!");
240 }
241
242 /**
243 * @tc.name: BatteryService011
244 * @tc.desc: Test functions GetNowCurrent
245 * @tc.type: FUNC
246 * @tc.require: issueI5YZR1
247 */
248 static HWTEST_F(BatteryServiceTest, BatteryService011, TestSize.Level1)
249 {
250 BATTERY_HILOGI(LABEL_TEST, "BatteryService011 function start!");
251 EXPECT_NE(g_service->GetNowCurrentInner(), ERR_NO_INIT);
252 BATTERY_HILOGI(LABEL_TEST, "BatteryService011 function end!");
253 }
254
255 /**
256 * @tc.name: BatteryService012
257 * @tc.desc: Test functions GetTechnology
258 * @tc.type: FUNC
259 * @tc.require: issueI5YZR1
260 */
261 static HWTEST_F(BatteryServiceTest, BatteryService012, TestSize.Level1)
262 {
263 BATTERY_HILOGI(LABEL_TEST, "BatteryService012 function start!");
264 EXPECT_FALSE(g_service->GetTechnologyInner().empty());
265 BATTERY_HILOGI(LABEL_TEST, "BatteryService012 function end!");
266 }
267
268 /**
269 * @tc.name: BatteryService013
270 * @tc.desc: Test functions GetPluggedType
271 * @tc.type: FUNC
272 * @tc.require: issueI5YZR1
273 */
274 static HWTEST_F(BatteryServiceTest, BatteryService013, TestSize.Level1)
275 {
276 BATTERY_HILOGI(LABEL_TEST, "BatteryService013 function start!");
277 BatteryPluggedType pluggedType = g_service->GetPluggedTypeInner();
278 EXPECT_TRUE(
279 pluggedType >= BatteryPluggedType::PLUGGED_TYPE_NONE && pluggedType <= BatteryPluggedType::PLUGGED_TYPE_BUTT);
280 BATTERY_HILOGI(LABEL_TEST, "BatteryService013 function end!");
281 }
282
283 /**
284 * @tc.name: BatteryService014
285 * @tc.desc: Test functions GetCurrentAverage
286 * @tc.type: FUNC
287 * @tc.require: issueI5YZR1
288 */
289 static HWTEST_F(BatteryServiceTest, BatteryService014, TestSize.Level1)
290 {
291 BATTERY_HILOGI(LABEL_TEST, "BatteryService014 function start!");
292 EXPECT_NE(g_service->GetCurrentAverageInner(), ERR_NO_INIT);
293 BATTERY_HILOGI(LABEL_TEST, "BatteryService014 function end!");
294 }
295
296 /**
297 * @tc.name: BatteryService015
298 * @tc.desc: Test functions GetHealthStatus
299 * @tc.type: FUNC
300 * @tc.require: issueI5YZR1
301 */
302 static HWTEST_F(BatteryServiceTest, BatteryService015, TestSize.Level1)
303 {
304 BATTERY_HILOGI(LABEL_TEST, "BatteryService015 function start!");
305 BatteryHealthState healthState = g_service->GetHealthStatusInner();
306 EXPECT_TRUE(healthState >= BatteryHealthState::HEALTH_STATE_UNKNOWN &&
307 healthState <= BatteryHealthState::HEALTH_STATE_BUTT);
308 BATTERY_HILOGI(LABEL_TEST, "BatteryService015 function end!");
309 }
310
311 /**
312 * @tc.name: BatteryService016
313 * @tc.desc: Test functions GetChargingStatus
314 * @tc.type: FUNC
315 * @tc.require: issueI5YZR1
316 */
317 static HWTEST_F(BatteryServiceTest, BatteryService016, TestSize.Level1)
318 {
319 BATTERY_HILOGI(LABEL_TEST, "BatteryService016 function start!");
320 BatteryChargeState chargeState = g_service->GetChargingStatusInner();
321 EXPECT_TRUE(
322 chargeState >= BatteryChargeState::CHARGE_STATE_NONE && chargeState <= BatteryChargeState::CHARGE_STATE_BUTT);
323 BATTERY_HILOGI(LABEL_TEST, "BatteryService016 function end!");
324 }
325
326 /**
327 * @tc.name: BatteryService017
328 * @tc.desc: Test functions GetTotalEnergy
329 * @tc.type: FUNC
330 * @tc.require: issueI5YZR1
331 */
332 static HWTEST_F(BatteryServiceTest, BatteryService017, TestSize.Level1)
333 {
334 BATTERY_HILOGI(LABEL_TEST, "BatteryService017 function start!");
335 EXPECT_NE(g_service->GetTotalEnergyInner(), ERR_NO_INIT);
336 BATTERY_HILOGI(LABEL_TEST, "BatteryService017 function end!");
337 }
338
339 /**
340 * @tc.name: BatteryService018
341 * @tc.desc: Test functions HandleBatteryCallbackEvent
342 * @tc.type: FUNC
343 */
344 static HWTEST_F(BatteryServiceTest, BatteryService018, TestSize.Level1)
345 {
346 BATTERY_HILOGI(LABEL_TEST, "BatteryService018 function start!");
347 V2_0::BatteryInfo event;
348 event.capacity = 90; // Prevent shutdown
349 EXPECT_EQ(g_service->HandleBatteryCallbackEvent(event), ERR_OK);
350
351 int32_t fd = 1;
352 std::vector<std::u16string> args;
353 std::u16string arg = u"-u";
354 args.push_back(arg);
355 g_service->isBootCompleted_ = true;
356 EXPECT_EQ(g_service->Dump(fd, args), ERR_OK);
357
358 EXPECT_EQ(g_service->HandleBatteryCallbackEvent(event), ERR_OK);
359
360 args.clear();
361 arg = u"-r";
362 args.push_back(arg);
363 EXPECT_EQ(g_service->Dump(fd, args), ERR_OK);
364
365 EXPECT_EQ(g_service->HandleBatteryCallbackEvent(event), ERR_OK);
366 EXPECT_EQ(g_service->HandleBatteryCallbackEvent(event), ERR_OK);
367
368 BATTERY_HILOGI(LABEL_TEST, "BatteryService018 function end!");
369 }
370
371 /**
372 * @tc.name: BatteryService019
373 * @tc.desc: Test functions ChangePath
374 * @tc.type: FUNC
375 * @tc.require: issueI6O3E1
376 */
377 static HWTEST_F(BatteryServiceTest, BatteryService019, TestSize.Level1)
378 {
379 BATTERY_HILOGI(LABEL_TEST, "BatteryService019 function start!");
380 usleep(DELAY_TIME_US);
381 g_service->iBatteryInterface_ = nullptr;
382 auto ret = g_service->ChangePath("/data/service/el0/battery");
383 EXPECT_FALSE(ret);
384
385 g_service->iBatteryInterface_ = V2_0::IBatteryInterface::Get();
386 ret = g_service->ChangePath("/data/service/el0/battery");
387 EXPECT_TRUE(ret);
388
389 if (!g_isMock) {
390 ret = g_service->ChangePath("/sys/class/power_supply");
391 EXPECT_TRUE(ret);
392 }
393
394 BATTERY_HILOGI(LABEL_TEST, "BatteryService019 function end!");
395 }
396
397 /**
398 * @tc.name: BatteryService020
399 * @tc.desc: Test functions CalculateRemainingChargeTime
400 * @tc.type: FUNC
401 */
402 static HWTEST_F(BatteryServiceTest, BatteryService020, TestSize.Level1)
403 {
404 BATTERY_HILOGI(LABEL_TEST, "BatteryService020 function start!");
405 g_service->CalculateRemainingChargeTime(101, BatteryChargeState::CHARGE_STATE_DISABLE);
406 EXPECT_FALSE(g_service->chargeFlag_);
407
408 g_service->chargeFlag_ = true;
409 g_service->lastCapacity_ = 50;
410 g_service->CalculateRemainingChargeTime(30, BatteryChargeState::CHARGE_STATE_ENABLE);
411 EXPECT_EQ(g_service->lastCapacity_, 30);
412
413 g_service->lastCapacity_ = 50;
414 g_service->chargeFlag_ = true;
415 g_service->CalculateRemainingChargeTime(51, BatteryChargeState::CHARGE_STATE_ENABLE);
416
417 BATTERY_HILOGI(LABEL_TEST, "BatteryService020 function end!");
418 }
419
420 /**
421 * @tc.name: BatteryService021
422 * @tc.desc: Test functions GetCapacityLevel
423 * @tc.type: FUNC
424 */
425 static HWTEST_F(BatteryServiceTest, BatteryService021, TestSize.Level1)
426 {
427 BATTERY_HILOGI(LABEL_TEST, "BatteryService021 function start!");
428 if (g_isMock) {
429 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "1");
430 auto level = g_service->GetCapacityLevelInner();
431 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_SHUTDOWN);
432
433 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "4");
434 level = g_service->GetCapacityLevelInner();
435 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_CRITICAL);
436
437 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "10");
438 level = g_service->GetCapacityLevelInner();
439 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_WARNING);
440
441 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "15");
442 level = g_service->GetCapacityLevelInner();
443 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_LOW);
444
445 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "90");
446 level = g_service->GetCapacityLevelInner();
447 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_NORMAL);
448
449 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "99");
450 level = g_service->GetCapacityLevelInner();
451 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_HIGH);
452
453 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "100");
454 level = g_service->GetCapacityLevelInner();
455 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_FULL);
456
457 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "200");
458 level = g_service->GetCapacityLevelInner();
459 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_NONE);
460
461 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "50");
462 }
463 BATTERY_HILOGI(LABEL_TEST, "BatteryService021 function end!");
464 }
465
466 /**
467 * @tc.name: BatteryService022
468 * @tc.desc: Test functions GetChargeType
469 * @tc.type: FUNC
470 */
471 static HWTEST_F(BatteryServiceTest, BatteryService022, TestSize.Level1)
472 {
473 BATTERY_HILOGI(LABEL_TEST, "BatteryService022 function start!");
474 ChargeType chargeType = g_service->GetChargeType();
475 EXPECT_TRUE(chargeType >= ChargeType::NONE && chargeType <= ChargeType::WIRELESS_SUPER_QUICK);
476 BATTERY_HILOGI(LABEL_TEST, "BatteryService022 function end!");
477 }
478
479 /**
480 * @tc.name: BatteryService023
481 * @tc.desc: Test functions OnStop
482 * @tc.type: FUNC
483 */
484 static HWTEST_F(BatteryServiceTest, BatteryService023, TestSize.Level1)
485 {
486 BATTERY_HILOGI(LABEL_TEST, "BatteryService023 function start!");
487 g_service->ready_ = true;
488 g_service->OnStop();
489 EXPECT_FALSE(g_service->ready_);
490
491 g_service->ready_ = true;
492 g_service->iBatteryInterface_ = nullptr;
493 g_service->hdiServiceMgr_ = nullptr;
494 g_service->OnStop();
495 EXPECT_FALSE(g_service->ready_);
496 g_service->OnStart();
497
498 BATTERY_HILOGI(LABEL_TEST, "BatteryService023 function end!");
499 }
500
501 /**
502 * @tc.name: BatteryService024
503 * @tc.desc: Test functions GetVoltage
504 * @tc.type: FUNC
505 * @tc.require:
506 */
507 static HWTEST_F(BatteryServiceTest, BatteryService024, TestSize.Level1)
508 {
509 BATTERY_HILOGI(LABEL_TEST, "BatteryService024 function start!");
510 if (g_isMock) {
511 int32_t tempVoltage = 0;
512 EXPECT_EQ(g_service->GetVoltage(tempVoltage), ERR_OK);
513 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", "4654321");
514 int32_t voltage = 0;
515 g_service->GetVoltage(voltage);
516 EXPECT_TRUE(voltage == 4654321);
517 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", std::to_string(tempVoltage));
518 } else {
519 int32_t voltage = 0;
520 g_service->GetVoltage(voltage);
521 BATTERY_HILOGI(LABEL_TEST, "BatteryService024::voltage=%{public}d", voltage);
522 GTEST_LOG_(INFO) << "BatteryService024 executing, voltage=" << voltage;
523 EXPECT_TRUE(voltage >= 0);
524 }
525
526 BATTERY_HILOGI(LABEL_TEST, "BatteryService024 function end!");
527 }
528
529 /**
530 * @tc.name: BatteryService025
531 * @tc.desc: Test functions IsBatteryConfigSupported
532 * @tc.type: FUNC
533 */
534 static HWTEST_F(BatteryServiceTest, BatteryService025, TestSize.Level1)
535 {
536 BATTERY_HILOGI(LABEL_TEST, "BatteryService025 function start!");
537 string sceneName = "testScene";
538 int32_t batteryErr = static_cast<int32_t>(BatteryError::ERR_FAILURE);
539 bool result = false;
540 g_service->IsBatteryConfigSupported(sceneName, result, batteryErr);
541 EXPECT_EQ(batteryErr, static_cast<int32_t>(BatteryError::ERR_FAILURE));
542 BATTERY_HILOGI(LABEL_TEST, "BatteryService025 function end!");
543 }
544
545 /**
546 * @tc.name: BatteryService026
547 * @tc.desc: Test functions GetBatteryTemperature
548 * @tc.type: FUNC
549 * @tc.require:
550 */
551 static HWTEST_F(BatteryServiceTest, BatteryService026, TestSize.Level1)
552 {
553 BATTERY_HILOGI(LABEL_TEST, "BatteryService026 function start!");
554 if (g_isMock) {
555 int32_t tempTemperature = 0;
556 g_service->GetBatteryTemperature(tempTemperature);
557 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", "222");
558 int32_t temperature = 0;
559 g_service->GetBatteryTemperature(temperature);
560 BATTERY_HILOGI(LABEL_TEST, "BatteryService026::temperature=%{public}d", temperature);
561 GTEST_LOG_(INFO) << "BatteryService026 executing, temperature=" << temperature;
562 EXPECT_TRUE(temperature == 222);
563 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", std::to_string(tempTemperature));
564 } else {
565 int32_t temperature = 0;
566 g_service->GetBatteryTemperature(temperature);
567 BATTERY_HILOGI(LABEL_TEST, "BatteryService026::temperature=%{public}d", temperature);
568 GTEST_LOG_(INFO) << "BatteryService026 executing, temperature=" << temperature;
569 EXPECT_TRUE(temperature >= 0 && temperature <= 600);
570 }
571 BATTERY_HILOGI(LABEL_TEST, "BatteryService026 function end!");
572 }
573
574 /**
575 * @tc.name: BatteryService027
576 * @tc.desc: Test functions GetRemainEnergy
577 * @tc.type: FUNC
578 * @tc.require:
579 */
580 static HWTEST_F(BatteryServiceTest, BatteryService027, TestSize.Level1)
581 {
582 BATTERY_HILOGI(LABEL_TEST, "BatteryService027 function start!");
583 int32_t remainEnergy = 0;
584 g_service->GetRemainEnergy(remainEnergy);
585 EXPECT_NE(remainEnergy, ERR_NO_INIT);
586 BATTERY_HILOGI(LABEL_TEST, "BatteryService027 function end!");
587 }
588
589 /**
590 * @tc.name: BatteryService028
591 * @tc.desc: Test functions GetNowCurrent
592 * @tc.type: FUNC
593 * @tc.require:
594 */
595 static HWTEST_F(BatteryServiceTest, BatteryService028, TestSize.Level1)
596 {
597 BATTERY_HILOGI(LABEL_TEST, "BatteryService028 function start!");
598 int32_t nowCurrent = 0;
599 g_service->GetNowCurrent(nowCurrent);
600 EXPECT_NE(nowCurrent, ERR_NO_INIT);
601 BATTERY_HILOGI(LABEL_TEST, "BatteryService028 function end!");
602 }
603
604 /**
605 * @tc.name: BatteryService029
606 * @tc.desc: Test functions GetTechnology
607 * @tc.type: FUNC
608 * @tc.require:
609 */
610 static HWTEST_F(BatteryServiceTest, BatteryService029, TestSize.Level1)
611 {
612 BATTERY_HILOGI(LABEL_TEST, "BatteryService029 function start!");
613 std::string technology;
614 g_service->GetTechnology(technology);
615 EXPECT_FALSE(technology.empty());
616 BATTERY_HILOGI(LABEL_TEST, "BatteryService029 function end!");
617 }
618
619 /**
620 * @tc.name: BatteryService030
621 * @tc.desc: Test functions GetPluggedType
622 * @tc.type: FUNC
623 * @tc.require:
624 */
625 static HWTEST_F(BatteryServiceTest, BatteryService030, TestSize.Level1)
626 {
627 BATTERY_HILOGI(LABEL_TEST, "BatteryService030 function start!");
628 uint32_t pluggedTypeTemp = 0;
629 g_service->GetPluggedType(pluggedTypeTemp);
630 BatteryPluggedType pluggedType = static_cast<BatteryPluggedType>(pluggedTypeTemp);
631 EXPECT_TRUE(
632 pluggedType >= BatteryPluggedType::PLUGGED_TYPE_NONE && pluggedType <= BatteryPluggedType::PLUGGED_TYPE_BUTT);
633 BATTERY_HILOGI(LABEL_TEST, "BatteryService030 function end!");
634 }
635
636 /**
637 * @tc.name: BatteryService031
638 * @tc.desc: Test functions GetCurrentAverage
639 * @tc.type: FUNC
640 * @tc.require:
641 */
642 static HWTEST_F(BatteryServiceTest, BatteryService031, TestSize.Level1)
643 {
644 BATTERY_HILOGI(LABEL_TEST, "BatteryService031 function start!");
645 int32_t currentAverage = 0;
646 g_service->GetCurrentAverage(currentAverage);
647 EXPECT_NE(currentAverage, ERR_NO_INIT);
648 BATTERY_HILOGI(LABEL_TEST, "BatteryService031 function end!");
649 }
650
651 /**
652 * @tc.name: BatteryService032
653 * @tc.desc: Test functions GetHealthStatus
654 * @tc.type: FUNC
655 * @tc.require:
656 */
657 static HWTEST_F(BatteryServiceTest, BatteryService032, TestSize.Level1)
658 {
659 BATTERY_HILOGI(LABEL_TEST, "BatteryService032 function start!");
660 uint32_t healthStateTemp = 0;
661 g_service->GetHealthStatus(healthStateTemp);
662 BatteryHealthState healthState = static_cast<BatteryHealthState>(healthStateTemp);
663 EXPECT_TRUE(healthState >= BatteryHealthState::HEALTH_STATE_UNKNOWN &&
664 healthState <= BatteryHealthState::HEALTH_STATE_BUTT);
665 BATTERY_HILOGI(LABEL_TEST, "BatteryService032 function end!");
666 }
667
668 /**
669 * @tc.name: BatteryService033
670 * @tc.desc: Test functions GetChargingStatus
671 * @tc.type: FUNC
672 * @tc.require:
673 */
674 static HWTEST_F(BatteryServiceTest, BatteryService033, TestSize.Level1)
675 {
676 BATTERY_HILOGI(LABEL_TEST, "BatteryService033 function start!");
677 uint32_t chargingStateTemp = 0;
678 g_service->GetChargingStatus(chargingStateTemp);
679 BatteryChargeState chargeState = static_cast<BatteryChargeState>(chargingStateTemp);
680 EXPECT_TRUE(
681 chargeState >= BatteryChargeState::CHARGE_STATE_NONE && chargeState <= BatteryChargeState::CHARGE_STATE_BUTT);
682 BATTERY_HILOGI(LABEL_TEST, "BatteryService033 function end!");
683 }
684
685 /**
686 * @tc.name: BatteryService034
687 * @tc.desc: Test functions GetTotalEnergy
688 * @tc.type: FUNC
689 * @tc.require:
690 */
691 static HWTEST_F(BatteryServiceTest, BatteryService034, TestSize.Level1)
692 {
693 BATTERY_HILOGI(LABEL_TEST, "BatteryService034 function start!");
694 int32_t totalEnergy = 0;
695 g_service->GetTotalEnergy(totalEnergy);
696 EXPECT_NE(totalEnergy, ERR_NO_INIT);
697 BATTERY_HILOGI(LABEL_TEST, "BatteryService034 function end!");
698 }
699
700 /**
701 * @tc.name: BatteryService035
702 * @tc.desc: Test functions GetCapacityLevel
703 * @tc.type: FUNC
704 */
705 static HWTEST_F(BatteryServiceTest, BatteryService035, TestSize.Level1)
706 {
707 BATTERY_HILOGI(LABEL_TEST, "BatteryService035 function start!");
708 if (g_isMock) {
709 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "1");
710 uint32_t level = 0;
711 g_service->GetCapacityLevel(level);
712 EXPECT_EQ(static_cast<BatteryCapacityLevel>(level), BatteryCapacityLevel::LEVEL_SHUTDOWN);
713
714 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "4");
715 g_service->GetCapacityLevel(level);
716 EXPECT_EQ(static_cast<BatteryCapacityLevel>(level), BatteryCapacityLevel::LEVEL_CRITICAL);
717
718 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "10");
719 g_service->GetCapacityLevel(level);
720 EXPECT_EQ(static_cast<BatteryCapacityLevel>(level), BatteryCapacityLevel::LEVEL_WARNING);
721
722 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "15");
723 g_service->GetCapacityLevel(level);
724 EXPECT_EQ(static_cast<BatteryCapacityLevel>(level), BatteryCapacityLevel::LEVEL_LOW);
725
726 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "90");
727 g_service->GetCapacityLevel(level);
728 EXPECT_EQ(static_cast<BatteryCapacityLevel>(level), BatteryCapacityLevel::LEVEL_NORMAL);
729
730 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "99");
731 g_service->GetCapacityLevel(level);
732 EXPECT_EQ(static_cast<BatteryCapacityLevel>(level), BatteryCapacityLevel::LEVEL_HIGH);
733
734 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "100");
735 g_service->GetCapacityLevel(level);
736 EXPECT_EQ(static_cast<BatteryCapacityLevel>(level), BatteryCapacityLevel::LEVEL_FULL);
737
738 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "200");
739 g_service->GetCapacityLevel(level);
740 EXPECT_EQ(static_cast<BatteryCapacityLevel>(level), BatteryCapacityLevel::LEVEL_NONE);
741
742 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "50");
743 }
744 BATTERY_HILOGI(LABEL_TEST, "BatteryService035 function end!");
745 }
746
747 /**
748 * @tc.name: BatteryService036
749 * @tc.desc: Test functions GetCapacity
750 * @tc.type: FUNC
751 * @tc.require: issueI5YZR1
752 */
753 HWTEST_F(BatteryServiceTest, BatteryService036, TestSize.Level1)
754 {
755 BATTERY_HILOGI(LABEL_TEST, "BatteryService036 function start!");
756 int32_t capacity = 0;
757 auto ret = g_service->GetCapacity(capacity);
758 EXPECT_EQ(ret, ERR_OK);
759 ASSERT_TRUE(capacity <= 100 && capacity >= 0);
760 BATTERY_HILOGI(LABEL_TEST, "BatteryService036 function end!");
761 }
762
763 /**
764 * @tc.name: BatteryService037
765 * @tc.desc: Test functions GetRemainingChargeTime
766 * @tc.type: FUNC
767 * @tc.require: issueI5YZR1
768 */
769 HWTEST_F(BatteryServiceTest, BatteryService037, TestSize.Level1)
770 {
771 BATTERY_HILOGI(LABEL_TEST, "BatteryService037 function start!");
772 int64_t remainTime = 0;
773 auto ret = g_service->GetRemainingChargeTime(remainTime);
774 EXPECT_EQ(ret, ERR_OK);
775 ASSERT_TRUE(remainTime >= 0);
776 BATTERY_HILOGI(LABEL_TEST, "BatteryService037 function end!");
777 }
778
779 /**
780 * @tc.name: BatteryService038
781 * @tc.desc: Test functions GetRemainingChargeTime
782 * @tc.type: FUNC
783 * @tc.require:
784 */
785 HWTEST_F(BatteryServiceTest, BatteryService038, TestSize.Level1)
786 {
787 BATTERY_HILOGI(LABEL_TEST, "BatteryService038 function start!");
788 auto ret = g_service->CapacityLevelCompare(TEST_CAPACITY_FIRST, TEST_CAPACITY_MIN, TEST_CAPACITY_MAX);
789 ASSERT_TRUE(ret);
790 ret = g_service->CapacityLevelCompare(TEST_CAPACITY_FIRST, TEST_CAPACITY_SECOND, TEST_CAPACITY_MAX);
791 ASSERT_FALSE(ret);
792 BATTERY_HILOGI(LABEL_TEST, "BatteryService038 function end!");
793 }
794
795 /**
796 * @tc.name: BatteryService039
797 * @tc.desc: Test functions GetCapacityLevelInner
798 * @tc.type: FUNC
799 */
800 static HWTEST_F(BatteryServiceTest, BatteryService039, TestSize.Level1)
801 {
802 BATTERY_HILOGI(LABEL_TEST, "BatteryService039 function start!");
803 if (g_isMock) {
804 auto tempCapacityThreshold = g_service->shutdownCapacityThreshold_;
805 g_service->shutdownCapacityThreshold_ = 0;
806 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "1");
807 auto level = g_service->GetCapacityLevelInner();
808 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_CRITICAL);
809 g_service->shutdownCapacityThreshold_ = tempCapacityThreshold;
810 tempCapacityThreshold = g_service->criticalCapacityThreshold_;
811 g_service->criticalCapacityThreshold_ = 0;
812 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "4");
813 level = g_service->GetCapacityLevelInner();
814 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_WARNING);
815 g_service->criticalCapacityThreshold_ = tempCapacityThreshold;
816 tempCapacityThreshold = g_service->warningCapacityThreshold_;
817 g_service->warningCapacityThreshold_ = 0;
818 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "10");
819 level = g_service->GetCapacityLevelInner();
820 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_LOW);
821 g_service->warningCapacityThreshold_ = tempCapacityThreshold;
822 tempCapacityThreshold = g_service->lowCapacityThreshold_;
823 g_service->lowCapacityThreshold_ = 0;
824 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "15");
825 level = g_service->GetCapacityLevelInner();
826 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_NORMAL);
827 g_service->lowCapacityThreshold_ = tempCapacityThreshold;
828 tempCapacityThreshold = g_service->normalCapacityThreshold_;
829 g_service->normalCapacityThreshold_ = 0;
830 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "90");
831 level = g_service->GetCapacityLevelInner();
832 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_HIGH);
833 g_service->normalCapacityThreshold_ = tempCapacityThreshold;
834 tempCapacityThreshold = g_service->highCapacityThreshold_;
835 g_service->highCapacityThreshold_ = 0;
836 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "99");
837 level = g_service->GetCapacityLevelInner();
838 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_FULL);
839 g_service->highCapacityThreshold_ = tempCapacityThreshold;
840 tempCapacityThreshold = g_service->fullCapacityThreshold_;
841 g_service->fullCapacityThreshold_ = 0;
842 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "100");
843 level = g_service->GetCapacityLevelInner();
844 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_NONE);
845 g_service->fullCapacityThreshold_ = tempCapacityThreshold;
846 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "50");
847 }
848 BATTERY_HILOGI(LABEL_TEST, "BatteryService039 function end!");
849 }
850
851 /**
852 * @tc.name: BatteryService040
853 * @tc.desc: Test functions SetBatteryConfig
854 * @tc.type: FUNC
855 */
856 static HWTEST_F(BatteryServiceTest, BatteryService040, TestSize.Level1)
857 {
858 BATTERY_HILOGI(LABEL_TEST, "BatteryService040 function start!");
859 string sceneName = "testScene";
860 string value = "";
861 int32_t batteryErr = static_cast<int32_t>(BatteryError::ERR_FAILURE);
862 g_service->SetBatteryConfig(sceneName, value, batteryErr);
863 EXPECT_EQ(batteryErr, static_cast<int32_t>(BatteryError::ERR_SYSTEM_API_DENIED));
864 BATTERY_HILOGI(LABEL_TEST, "BatteryService040 function end!");
865 }
866
867 /**
868 * @tc.name: BatteryService041
869 * @tc.desc: Test functions GetBatteryConfig
870 * @tc.type: FUNC
871 */
872 static HWTEST_F(BatteryServiceTest, BatteryService041, TestSize.Level1)
873 {
874 BATTERY_HILOGI(LABEL_TEST, "BatteryService041 function start!");
875 string sceneName = "testScene";
876 string result = "";
877 int32_t batteryErr = static_cast<int32_t>(BatteryError::ERR_FAILURE);
878 g_service->GetBatteryConfig(sceneName, result, batteryErr);
879 EXPECT_EQ(batteryErr, static_cast<int32_t>(BatteryError::ERR_FAILURE));
880 BATTERY_HILOGI(LABEL_TEST, "BatteryService041 function end!");
881 }
882
883 /**
884 * @tc.name: BatteryXCollie001
885 * @tc.desc: Test functions BatteryXCollie default
886 * @tc.type: FUNC
887 */
888 HWTEST_F(BatteryServiceTest, BatteryXCollie001, TestSize.Level1)
889 {
890 BATTERY_HILOGI(LABEL_TEST, "BatteryXCollie001 function start!");
891 BatteryXCollie batteryXCollie("BatteryService::SetBatteryConfig");
892 EXPECT_FALSE(batteryXCollie.isCanceled_);
893 batteryXCollie.CancelBatteryXCollie();
894 EXPECT_TRUE(batteryXCollie.isCanceled_);
895 BATTERY_HILOGI(LABEL_TEST, "BatteryXCollie001 function end!");
896 }
897
898 /**
899 * @tc.name: BatteryXCollie002
900 * @tc.desc: Test functions BatteryXCollie isRecovery=true
901 * @tc.type: FUNC
902 */
903 HWTEST_F(BatteryServiceTest, BatteryXCollie002, TestSize.Level1)
904 {
905 BATTERY_HILOGI(LABEL_TEST, "BatteryXCollie002 function start!");
906 BatteryXCollie batteryXCollie("BatteryService::SetBatteryConfig", true);
907 EXPECT_FALSE(batteryXCollie.isCanceled_);
908 batteryXCollie.CancelBatteryXCollie();
909 EXPECT_TRUE(batteryXCollie.isCanceled_);
910 BATTERY_HILOGI(LABEL_TEST, "BatteryXCollie002 function end!");
911 }
912
913 /**
914 * @tc.name: BatteryXCollie003
915 * @tc.desc: Test functions BatteryXCollie logtag empty
916 * @tc.type: FUNC
917 */
918 HWTEST_F(BatteryServiceTest, BatteryXCollie003, TestSize.Level1)
919 {
920 BATTERY_HILOGI(LABEL_TEST, "BatteryXCollie003 function start!");
921 std::string emptyString;
922 BatteryXCollie batteryXCollie(emptyString);
923 EXPECT_FALSE(batteryXCollie.isCanceled_);
924 batteryXCollie.CancelBatteryXCollie();
925 EXPECT_TRUE(batteryXCollie.isCanceled_);
926 BATTERY_HILOGI(LABEL_TEST, "BatteryXCollie003 function end!");
927 }