1 /*
2 * Copyright (c) 2022-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_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
36 using namespace testing::ext;
37 using namespace OHOS::PowerMgr;
38 using namespace OHOS::EventFwk;
39 using namespace OHOS::HDI::Battery;
40 using namespace OHOS;
41 using namespace std;
42
43 namespace {
44 sptr<BatteryService> g_service;
45 bool g_isMock = TestUtils::IsMock();
46 const std::string MOCK_BATTERY_PATH = "/data/service/el0/battery/";
47 constexpr int DELAY_TIME_US = 2000;
48 }
49
TearDownTestCase(void)50 void BatteryServiceTest::TearDownTestCase(void)
51 {
52 g_service->Reset();
53 }
54
55 /**
56 * @tc.name: BatteryService000
57 * @tc.desc: Test functions DelayedSpSingleton GetInstance
58 * @tc.type: FUNC
59 * @tc.require: issueI5YZR1
60 */
61 static HWTEST_F(BatteryServiceTest, BatteryService000, TestSize.Level1)
62 {
63 BATTERY_HILOGD(LABEL_TEST, "BatteryService000 start.");
64 g_service = DelayedSpSingleton<BatteryService>::GetInstance();
65 EXPECT_TRUE(g_service != nullptr);
66 g_service->OnStart();
67 g_service = nullptr;
68 g_service = DelayedSpSingleton<BatteryService>::GetInstance();
69 EXPECT_TRUE(g_service != nullptr);
70 BATTERY_HILOGD(LABEL_TEST, "BatteryService000 end.");
71 }
72
73 /**
74 * @tc.name: BatteryService001
75 * @tc.desc: Test functions RegisterBatteryHdiCallback
76 * @tc.type: FUNC
77 * @tc.require: issueI5YZR1
78 */
79 static HWTEST_F(BatteryServiceTest, BatteryService001, TestSize.Level1)
80 {
81 BATTERY_HILOGD(LABEL_TEST, "BatteryService001 start.");
82 EXPECT_TRUE(g_service->RegisterBatteryHdiCallback());
83 BATTERY_HILOGD(LABEL_TEST, "BatteryService001 end.");
84 }
85
86 /**
87 * @tc.name: BatteryService004
88 * @tc.desc: Test functions GetVoltage
89 * @tc.type: FUNC
90 * @tc.require: issueI5YZR1
91 */
92 static HWTEST_F(BatteryServiceTest, BatteryService004, TestSize.Level1)
93 {
94 BATTERY_HILOGD(LABEL_TEST, "BatteryService004 start.");
95 if (g_isMock) {
96 auto tempVoltage = g_service->GetVoltage();
97 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", "4654321");
98 auto voltage = g_service->GetVoltage();
99 EXPECT_TRUE(voltage == 4654321);
100 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", std::to_string(tempVoltage));
101 } else {
102 auto voltage = g_service->GetVoltage();
103 BATTERY_HILOGI(LABEL_TEST, "BatteryService004::voltage=%{public}d", voltage);
104 GTEST_LOG_(INFO) << "BatteryService004 executing, voltage=" << voltage;
105 EXPECT_TRUE(voltage >= 0);
106 }
107
108 BATTERY_HILOGD(LABEL_TEST, "BatteryService004 end.");
109 }
110
111 /**
112 * @tc.name: BatteryService005
113 * @tc.desc: Test functions GetPresent
114 * @tc.type: FUNC
115 * @tc.require: issueI5YZR1
116 */
117 static HWTEST_F(BatteryServiceTest, BatteryService005, TestSize.Level1)
118 {
119 BATTERY_HILOGD(LABEL_TEST, "BatteryService005 start.");
120 if (g_isMock) {
121 auto tempPresent = g_service->GetPresent();
122 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", "0");
123 auto present = g_service->GetPresent();
124 BATTERY_HILOGI(LABEL_TEST, "BatteryService005::present=%{public}d", present);
125 GTEST_LOG_(INFO) << "BatteryService005 executing, present=" << present;
126 EXPECT_FALSE(present);
127 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", std::to_string(tempPresent));
128 } else {
129 auto present = g_service->GetPresent();
130 BATTERY_HILOGI(LABEL_TEST, "BatteryService005::present=%{public}d", present);
131 GTEST_LOG_(INFO) << "BatteryService005 executing, present=" << present;
132 EXPECT_TRUE(present);
133 }
134 BATTERY_HILOGD(LABEL_TEST, "BatteryService005 end.");
135 }
136
137 /**
138 * @tc.name: BatteryService006
139 * @tc.desc: Test functions GetBatteryTemperature
140 * @tc.type: FUNC
141 * @tc.require: issueI5YZR1
142 */
143 static HWTEST_F(BatteryServiceTest, BatteryService006, TestSize.Level1)
144 {
145 BATTERY_HILOGD(LABEL_TEST, "BatteryService006 start.");
146 if (g_isMock) {
147 auto tempTempPresent = g_service->GetBatteryTemperature();
148 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", "222");
149 auto temperature = g_service->GetBatteryTemperature();
150 BATTERY_HILOGI(LABEL_TEST, "BatteryService006::temperature=%{public}d", temperature);
151 GTEST_LOG_(INFO) << "BatteryService006 executing, temperature=" << temperature;
152 EXPECT_TRUE(temperature == 222);
153 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", std::to_string(tempTempPresent));
154 } else {
155 auto temperature = g_service->GetBatteryTemperature();
156 BATTERY_HILOGI(LABEL_TEST, "BatteryService006::temperature=%{public}d", temperature);
157 GTEST_LOG_(INFO) << "BatteryService006 executing, temperature=" << temperature;
158 EXPECT_TRUE(temperature >= 0 && temperature <= 600);
159 }
160 BATTERY_HILOGD(LABEL_TEST, "BatteryService006 end.");
161 }
162
163 /**
164 * @tc.name: BatteryService012
165 * @tc.desc: Test functions RegisterHdiStatusListener
166 * @tc.type: FUNC
167 * @tc.require: issueI5YZR1
168 */
169 static HWTEST_F(BatteryServiceTest, BatteryService007, TestSize.Level1)
170 {
171 BATTERY_HILOGD(LABEL_TEST, "BatteryService007 start.");
172 EXPECT_TRUE(g_service->RegisterHdiStatusListener());
173 BATTERY_HILOGD(LABEL_TEST, "BatteryService007 end.");
174 }
175
176 /**
177 * @tc.name: BatteryService008
178 * @tc.desc: Test functions OnStart and OnStop and OnAddSystemAbility
179 * @tc.type: FUNC
180 * @tc.require: issueI5YZR1
181 */
182 static HWTEST_F(BatteryServiceTest, BatteryService008, TestSize.Level1)
183 {
184 BATTERY_HILOGD(LABEL_TEST, "BatteryService008 start.");
185 g_service->OnStart();
186 g_service->OnStart();
187 g_service->OnStop();
188 g_service->OnStop();
189 int32_t systemAbilityId = 3602; // MISCDEVICE_SERVICE_ABILITY_ID
190 g_service->OnAddSystemAbility(systemAbilityId, std::string("BatteryService008"));
191 g_service->OnAddSystemAbility(0, std::string("BatteryService008"));
192 g_service->ready_ = true;
193 g_service->OnStart();
194 EXPECT_TRUE(g_service->ready_);
195 g_service->OnStop();
196 EXPECT_FALSE(g_service->ready_);
197
198 g_service->OnStart();
199 g_service->iBatteryInterface_ = V2_0::IBatteryInterface::Get();
200 BATTERY_HILOGD(LABEL_TEST, "BatteryService008 end.");
201 }
202
203 /**
204 * @tc.name: BatteryService009
205 * @tc.desc: Test functions MockUnplugged
206 * @tc.type: FUNC
207 * @tc.require: issueI5YZR1
208 */
209 static HWTEST_F(BatteryServiceTest, BatteryService009, TestSize.Level1)
210 {
211 BATTERY_HILOGD(LABEL_TEST, "BatteryService009 start.");
212 usleep(DELAY_TIME_US);
213 g_service->MockUnplugged();
214 EXPECT_EQ(g_service->IsMockUnplugged(), true);
215 BATTERY_HILOGD(LABEL_TEST, "BatteryService009 end.");
216 }
217
218 /**
219 * @tc.name: BatteryService010
220 * @tc.desc: Test functions GetRemainEnergy
221 * @tc.type: FUNC
222 * @tc.require: issueI5YZR1
223 */
224 static HWTEST_F(BatteryServiceTest, BatteryService010, TestSize.Level1)
225 {
226 BATTERY_HILOGD(LABEL_TEST, "BatteryService010 start.");
227 EXPECT_NE(g_service->GetRemainEnergy(), ERR_NO_INIT);
228 BATTERY_HILOGD(LABEL_TEST, "BatteryService010 end.");
229 }
230
231 /**
232 * @tc.name: BatteryService011
233 * @tc.desc: Test functions GetNowCurrent
234 * @tc.type: FUNC
235 * @tc.require: issueI5YZR1
236 */
237 static HWTEST_F(BatteryServiceTest, BatteryService011, TestSize.Level1)
238 {
239 BATTERY_HILOGD(LABEL_TEST, "BatteryService011 start.");
240 EXPECT_NE(g_service->GetNowCurrent(), ERR_NO_INIT);
241 BATTERY_HILOGD(LABEL_TEST, "BatteryService011 end.");
242 }
243
244 /**
245 * @tc.name: BatteryService012
246 * @tc.desc: Test functions GetTechnology
247 * @tc.type: FUNC
248 * @tc.require: issueI5YZR1
249 */
250 static HWTEST_F(BatteryServiceTest, BatteryService012, TestSize.Level1)
251 {
252 BATTERY_HILOGD(LABEL_TEST, "BatteryService012 start.");
253 EXPECT_FALSE(g_service->GetTechnology().empty());
254 BATTERY_HILOGD(LABEL_TEST, "BatteryService012 end.");
255 }
256
257 /**
258 * @tc.name: BatteryService013
259 * @tc.desc: Test functions GetPluggedType
260 * @tc.type: FUNC
261 * @tc.require: issueI5YZR1
262 */
263 static HWTEST_F(BatteryServiceTest, BatteryService013, TestSize.Level1)
264 {
265 BATTERY_HILOGD(LABEL_TEST, "BatteryService013 start.");
266 BatteryPluggedType pluggedType = g_service->GetPluggedType();
267 EXPECT_TRUE(
268 pluggedType >= BatteryPluggedType::PLUGGED_TYPE_NONE && pluggedType <= BatteryPluggedType::PLUGGED_TYPE_BUTT);
269 BATTERY_HILOGD(LABEL_TEST, "BatteryService013 end.");
270 }
271
272 /**
273 * @tc.name: BatteryService014
274 * @tc.desc: Test functions GetCurrentAverage
275 * @tc.type: FUNC
276 * @tc.require: issueI5YZR1
277 */
278 static HWTEST_F(BatteryServiceTest, BatteryService014, TestSize.Level1)
279 {
280 BATTERY_HILOGD(LABEL_TEST, "BatteryService014 start.");
281 EXPECT_NE(g_service->GetCurrentAverage(), ERR_NO_INIT);
282 BATTERY_HILOGD(LABEL_TEST, "BatteryService014 end.");
283 }
284
285 /**
286 * @tc.name: BatteryService015
287 * @tc.desc: Test functions GetHealthStatus
288 * @tc.type: FUNC
289 * @tc.require: issueI5YZR1
290 */
291 static HWTEST_F(BatteryServiceTest, BatteryService015, TestSize.Level1)
292 {
293 BATTERY_HILOGD(LABEL_TEST, "BatteryService015 start.");
294 BatteryHealthState healthState = g_service->GetHealthStatus();
295 EXPECT_TRUE(healthState >= BatteryHealthState::HEALTH_STATE_UNKNOWN &&
296 healthState <= BatteryHealthState::HEALTH_STATE_BUTT);
297 BATTERY_HILOGD(LABEL_TEST, "BatteryService015 end.");
298 }
299
300 /**
301 * @tc.name: BatteryService016
302 * @tc.desc: Test functions GetChargingStatus
303 * @tc.type: FUNC
304 * @tc.require: issueI5YZR1
305 */
306 static HWTEST_F(BatteryServiceTest, BatteryService016, TestSize.Level1)
307 {
308 BATTERY_HILOGD(LABEL_TEST, "BatteryService016 start.");
309 BatteryChargeState chargeState = g_service->GetChargingStatus();
310 EXPECT_TRUE(
311 chargeState >= BatteryChargeState::CHARGE_STATE_NONE && chargeState <= BatteryChargeState::CHARGE_STATE_BUTT);
312 BATTERY_HILOGD(LABEL_TEST, "BatteryService016 end.");
313 }
314
315 /**
316 * @tc.name: BatteryService017
317 * @tc.desc: Test functions GetTotalEnergy
318 * @tc.type: FUNC
319 * @tc.require: issueI5YZR1
320 */
321 static HWTEST_F(BatteryServiceTest, BatteryService017, TestSize.Level1)
322 {
323 BATTERY_HILOGD(LABEL_TEST, "BatteryService017 start.");
324 EXPECT_NE(g_service->GetTotalEnergy(), ERR_NO_INIT);
325 BATTERY_HILOGD(LABEL_TEST, "BatteryService017 end.");
326 }
327
328 /**
329 * @tc.name: BatteryService018
330 * @tc.desc: Test functions HandleBatteryCallbackEvent
331 * @tc.type: FUNC
332 */
333 static HWTEST_F(BatteryServiceTest, BatteryService018, TestSize.Level1)
334 {
335 BATTERY_HILOGD(LABEL_TEST, "BatteryService018 start.");
336 V2_0::BatteryInfo event;
337 event.capacity = 90; // Prevent shutdown
338 EXPECT_EQ(g_service->HandleBatteryCallbackEvent(event), ERR_OK);
339
340 int32_t fd = 1;
341 std::vector<std::u16string> args;
342 std::u16string arg = u"-u";
343 args.push_back(arg);
344 g_service->isBootCompleted_ = true;
345 EXPECT_EQ(g_service->Dump(fd, args), ERR_OK);
346
347 EXPECT_EQ(g_service->HandleBatteryCallbackEvent(event), ERR_OK);
348
349 args.clear();
350 arg = u"-r";
351 args.push_back(arg);
352 EXPECT_EQ(g_service->Dump(fd, args), ERR_OK);
353
354 EXPECT_EQ(g_service->HandleBatteryCallbackEvent(event), ERR_OK);
355 EXPECT_EQ(g_service->HandleBatteryCallbackEvent(event), ERR_OK);
356
357 BATTERY_HILOGD(LABEL_TEST, "BatteryService018 end.");
358 }
359
360 /**
361 * @tc.name: BatteryService019
362 * @tc.desc: Test functions ChangePath
363 * @tc.type: FUNC
364 * @tc.require: issueI6O3E1
365 */
366 static HWTEST_F(BatteryServiceTest, BatteryService019, TestSize.Level1)
367 {
368 BATTERY_HILOGD(LABEL_TEST, "BatteryService019 start.");
369 usleep(DELAY_TIME_US);
370 g_service->iBatteryInterface_ = nullptr;
371 auto ret = g_service->ChangePath("/data/service/el0/battery");
372 EXPECT_FALSE(ret);
373
374 g_service->iBatteryInterface_ = V2_0::IBatteryInterface::Get();
375 ret = g_service->ChangePath("/data/service/el0/battery");
376 EXPECT_TRUE(ret);
377
378 if (!g_isMock) {
379 ret = g_service->ChangePath("/sys/class/power_supply");
380 EXPECT_TRUE(ret);
381 }
382
383 BATTERY_HILOGD(LABEL_TEST, "BatteryService019 end.");
384 }
385
386 /**
387 * @tc.name: BatteryService020
388 * @tc.desc: Test functions CalculateRemainingChargeTime
389 * @tc.type: FUNC
390 */
391 static HWTEST_F(BatteryServiceTest, BatteryService020, TestSize.Level1)
392 {
393 BATTERY_HILOGD(LABEL_TEST, "BatteryService020 start.");
394 g_service->CalculateRemainingChargeTime(101, BatteryChargeState::CHARGE_STATE_DISABLE);
395 EXPECT_FALSE(g_service->chargeFlag_);
396
397 g_service->chargeFlag_ = true;
398 g_service->lastCapacity_ = 50;
399 g_service->CalculateRemainingChargeTime(30, BatteryChargeState::CHARGE_STATE_ENABLE);
400 EXPECT_EQ(g_service->lastCapacity_, 30);
401
402 g_service->lastCapacity_ = 50;
403 g_service->chargeFlag_ = true;
404 g_service->CalculateRemainingChargeTime(51, BatteryChargeState::CHARGE_STATE_ENABLE);
405
406 BATTERY_HILOGD(LABEL_TEST, "BatteryService020 end.");
407 }
408
409 /**
410 * @tc.name: BatteryService021
411 * @tc.desc: Test functions GetCapacityLevel
412 * @tc.type: FUNC
413 */
414 static HWTEST_F(BatteryServiceTest, BatteryService021, TestSize.Level1)
415 {
416 BATTERY_HILOGD(LABEL_TEST, "BatteryService021 start.");
417 if (g_isMock) {
418 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "1");
419 auto level = g_service->GetCapacityLevel();
420 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_SHUTDOWN);
421
422 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "4");
423 level = g_service->GetCapacityLevel();
424 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_CRITICAL);
425
426 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "10");
427 level = g_service->GetCapacityLevel();
428 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_WARNING);
429
430 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "15");
431 level = g_service->GetCapacityLevel();
432 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_LOW);
433
434 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "90");
435 level = g_service->GetCapacityLevel();
436 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_NORMAL);
437
438 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "99");
439 level = g_service->GetCapacityLevel();
440 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_HIGH);
441
442 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "100");
443 level = g_service->GetCapacityLevel();
444 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_FULL);
445
446 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "200");
447 level = g_service->GetCapacityLevel();
448 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_NONE);
449
450 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "50");
451 }
452 BATTERY_HILOGD(LABEL_TEST, "BatteryService021 end.");
453 }
454
455 /**
456 * @tc.name: BatteryService022
457 * @tc.desc: Test functions GetChargeType
458 * @tc.type: FUNC
459 */
460 static HWTEST_F(BatteryServiceTest, BatteryService022, TestSize.Level1)
461 {
462 BATTERY_HILOGD(LABEL_TEST, "BatteryService022 start.");
463 ChargeType chargeType = g_service->GetChargeType();
464 EXPECT_TRUE(chargeType >= ChargeType::NONE && chargeType <= ChargeType::WIRELESS_SUPER_QUICK);
465 BATTERY_HILOGD(LABEL_TEST, "BatteryService022 end.");
466 }
467
468 /**
469 * @tc.name: BatteryService023
470 * @tc.desc: Test functions OnStop
471 * @tc.type: FUNC
472 */
473 static HWTEST_F(BatteryServiceTest, BatteryService023, TestSize.Level1)
474 {
475 BATTERY_HILOGD(LABEL_TEST, "BatteryService023 start.");
476 g_service->ready_ = true;
477 g_service->OnStop();
478 EXPECT_FALSE(g_service->ready_);
479
480 g_service->ready_ = true;
481 g_service->iBatteryInterface_ = nullptr;
482 g_service->hdiServiceMgr_ = nullptr;
483 g_service->OnStop();
484 EXPECT_FALSE(g_service->ready_);
485 g_service->OnStart();
486
487 BATTERY_HILOGD(LABEL_TEST, "BatteryService023 end.");
488 }
489