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 g_service->MockUnplugged();
213 EXPECT_EQ(g_service->IsMockUnplugged(), true);
214 BATTERY_HILOGD(LABEL_TEST, "BatteryService009 end.");
215 }
216
217 /**
218 * @tc.name: BatteryService010
219 * @tc.desc: Test functions GetRemainEnergy
220 * @tc.type: FUNC
221 * @tc.require: issueI5YZR1
222 */
223 static HWTEST_F(BatteryServiceTest, BatteryService010, TestSize.Level1)
224 {
225 BATTERY_HILOGD(LABEL_TEST, "BatteryService010 start.");
226 EXPECT_NE(g_service->GetRemainEnergy(), ERR_NO_INIT);
227 BATTERY_HILOGD(LABEL_TEST, "BatteryService010 end.");
228 }
229
230 /**
231 * @tc.name: BatteryService011
232 * @tc.desc: Test functions GetNowCurrent
233 * @tc.type: FUNC
234 * @tc.require: issueI5YZR1
235 */
236 static HWTEST_F(BatteryServiceTest, BatteryService011, TestSize.Level1)
237 {
238 BATTERY_HILOGD(LABEL_TEST, "BatteryService011 start.");
239 EXPECT_NE(g_service->GetNowCurrent(), ERR_NO_INIT);
240 BATTERY_HILOGD(LABEL_TEST, "BatteryService011 end.");
241 }
242
243 /**
244 * @tc.name: BatteryService012
245 * @tc.desc: Test functions GetTechnology
246 * @tc.type: FUNC
247 * @tc.require: issueI5YZR1
248 */
249 static HWTEST_F(BatteryServiceTest, BatteryService012, TestSize.Level1)
250 {
251 BATTERY_HILOGD(LABEL_TEST, "BatteryService012 start.");
252 EXPECT_FALSE(g_service->GetTechnology().empty());
253 BATTERY_HILOGD(LABEL_TEST, "BatteryService012 end.");
254 }
255
256 /**
257 * @tc.name: BatteryService013
258 * @tc.desc: Test functions GetPluggedType
259 * @tc.type: FUNC
260 * @tc.require: issueI5YZR1
261 */
262 static HWTEST_F(BatteryServiceTest, BatteryService013, TestSize.Level1)
263 {
264 BATTERY_HILOGD(LABEL_TEST, "BatteryService013 start.");
265 BatteryPluggedType pluggedType = g_service->GetPluggedType();
266 EXPECT_TRUE(
267 pluggedType >= BatteryPluggedType::PLUGGED_TYPE_NONE && pluggedType <= BatteryPluggedType::PLUGGED_TYPE_BUTT);
268 BATTERY_HILOGD(LABEL_TEST, "BatteryService013 end.");
269 }
270
271 /**
272 * @tc.name: BatteryService014
273 * @tc.desc: Test functions GetCurrentAverage
274 * @tc.type: FUNC
275 * @tc.require: issueI5YZR1
276 */
277 static HWTEST_F(BatteryServiceTest, BatteryService014, TestSize.Level1)
278 {
279 BATTERY_HILOGD(LABEL_TEST, "BatteryService014 start.");
280 EXPECT_NE(g_service->GetCurrentAverage(), ERR_NO_INIT);
281 BATTERY_HILOGD(LABEL_TEST, "BatteryService014 end.");
282 }
283
284 /**
285 * @tc.name: BatteryService015
286 * @tc.desc: Test functions GetHealthStatus
287 * @tc.type: FUNC
288 * @tc.require: issueI5YZR1
289 */
290 static HWTEST_F(BatteryServiceTest, BatteryService015, TestSize.Level1)
291 {
292 BATTERY_HILOGD(LABEL_TEST, "BatteryService015 start.");
293 BatteryHealthState healthState = g_service->GetHealthStatus();
294 EXPECT_TRUE(healthState >= BatteryHealthState::HEALTH_STATE_UNKNOWN &&
295 healthState <= BatteryHealthState::HEALTH_STATE_BUTT);
296 BATTERY_HILOGD(LABEL_TEST, "BatteryService015 end.");
297 }
298
299 /**
300 * @tc.name: BatteryService016
301 * @tc.desc: Test functions GetChargingStatus
302 * @tc.type: FUNC
303 * @tc.require: issueI5YZR1
304 */
305 static HWTEST_F(BatteryServiceTest, BatteryService016, TestSize.Level1)
306 {
307 BATTERY_HILOGD(LABEL_TEST, "BatteryService016 start.");
308 BatteryChargeState chargeState = g_service->GetChargingStatus();
309 EXPECT_TRUE(
310 chargeState >= BatteryChargeState::CHARGE_STATE_NONE && chargeState <= BatteryChargeState::CHARGE_STATE_BUTT);
311 BATTERY_HILOGD(LABEL_TEST, "BatteryService016 end.");
312 }
313
314 /**
315 * @tc.name: BatteryService017
316 * @tc.desc: Test functions GetTotalEnergy
317 * @tc.type: FUNC
318 * @tc.require: issueI5YZR1
319 */
320 static HWTEST_F(BatteryServiceTest, BatteryService017, TestSize.Level1)
321 {
322 BATTERY_HILOGD(LABEL_TEST, "BatteryService017 start.");
323 EXPECT_NE(g_service->GetTotalEnergy(), ERR_NO_INIT);
324 BATTERY_HILOGD(LABEL_TEST, "BatteryService017 end.");
325 }
326
327 /**
328 * @tc.name: BatteryService018
329 * @tc.desc: Test functions HandleBatteryCallbackEvent
330 * @tc.type: FUNC
331 */
332 static HWTEST_F(BatteryServiceTest, BatteryService018, TestSize.Level1)
333 {
334 BATTERY_HILOGD(LABEL_TEST, "BatteryService018 start.");
335 V2_0::BatteryInfo event;
336 event.capacity = 90; // Prevent shutdown
337 EXPECT_EQ(g_service->HandleBatteryCallbackEvent(event), ERR_OK);
338
339 int32_t fd = 1;
340 std::vector<std::u16string> args;
341 std::u16string arg = u"-u";
342 args.push_back(arg);
343 g_service->isBootCompleted_ = true;
344 EXPECT_EQ(g_service->Dump(fd, args), ERR_OK);
345
346 EXPECT_EQ(g_service->HandleBatteryCallbackEvent(event), ERR_OK);
347
348 args.clear();
349 arg = u"-r";
350 args.push_back(arg);
351 EXPECT_EQ(g_service->Dump(fd, args), ERR_OK);
352
353 EXPECT_EQ(g_service->HandleBatteryCallbackEvent(event), ERR_OK);
354 EXPECT_EQ(g_service->HandleBatteryCallbackEvent(event), ERR_OK);
355
356 BATTERY_HILOGD(LABEL_TEST, "BatteryService018 end.");
357 }
358
359 /**
360 * @tc.name: BatteryService019
361 * @tc.desc: Test functions ChangePath
362 * @tc.type: FUNC
363 * @tc.require: issueI6O3E1
364 */
365 static HWTEST_F(BatteryServiceTest, BatteryService019, TestSize.Level1)
366 {
367 BATTERY_HILOGD(LABEL_TEST, "BatteryService019 start.");
368 usleep(DELAY_TIME_US);
369 g_service->iBatteryInterface_ = nullptr;
370 auto ret = g_service->ChangePath("/data/service/el0/battery");
371 EXPECT_FALSE(ret);
372
373 g_service->iBatteryInterface_ = V2_0::IBatteryInterface::Get();
374 ret = g_service->ChangePath("/data/service/el0/battery");
375 EXPECT_TRUE(ret);
376
377 if (!g_isMock) {
378 ret = g_service->ChangePath("/sys/class/power_supply");
379 EXPECT_TRUE(ret);
380 }
381
382 BATTERY_HILOGD(LABEL_TEST, "BatteryService019 end.");
383 }
384
385 /**
386 * @tc.name: BatteryService020
387 * @tc.desc: Test functions CalculateRemainingChargeTime
388 * @tc.type: FUNC
389 */
390 static HWTEST_F(BatteryServiceTest, BatteryService020, TestSize.Level1)
391 {
392 BATTERY_HILOGD(LABEL_TEST, "BatteryService020 start.");
393 g_service->CalculateRemainingChargeTime(101, BatteryChargeState::CHARGE_STATE_DISABLE);
394 EXPECT_FALSE(g_service->chargeFlag_);
395
396 g_service->chargeFlag_ = true;
397 g_service->lastCapacity_ = 50;
398 g_service->CalculateRemainingChargeTime(30, BatteryChargeState::CHARGE_STATE_ENABLE);
399 EXPECT_EQ(g_service->lastCapacity_, 30);
400
401 g_service->lastCapacity_ = 50;
402 g_service->chargeFlag_ = true;
403 g_service->CalculateRemainingChargeTime(51, BatteryChargeState::CHARGE_STATE_ENABLE);
404
405 BATTERY_HILOGD(LABEL_TEST, "BatteryService020 end.");
406 }
407
408 /**
409 * @tc.name: BatteryService021
410 * @tc.desc: Test functions GetCapacityLevel
411 * @tc.type: FUNC
412 */
413 static HWTEST_F(BatteryServiceTest, BatteryService021, TestSize.Level1)
414 {
415 BATTERY_HILOGD(LABEL_TEST, "BatteryService021 start.");
416 if (g_isMock) {
417 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "1");
418 auto level = g_service->GetCapacityLevel();
419 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_SHUTDOWN);
420
421 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "4");
422 level = g_service->GetCapacityLevel();
423 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_CRITICAL);
424
425 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "10");
426 level = g_service->GetCapacityLevel();
427 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_WARNING);
428
429 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "15");
430 level = g_service->GetCapacityLevel();
431 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_LOW);
432
433 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "90");
434 level = g_service->GetCapacityLevel();
435 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_NORMAL);
436
437 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "99");
438 level = g_service->GetCapacityLevel();
439 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_HIGH);
440
441 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "100");
442 level = g_service->GetCapacityLevel();
443 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_FULL);
444
445 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "200");
446 level = g_service->GetCapacityLevel();
447 EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_NONE);
448
449 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "50");
450 }
451 BATTERY_HILOGD(LABEL_TEST, "BatteryService021 end.");
452 }
453
454 /**
455 * @tc.name: BatteryService022
456 * @tc.desc: Test functions GetChargeType
457 * @tc.type: FUNC
458 */
459 static HWTEST_F(BatteryServiceTest, BatteryService022, TestSize.Level1)
460 {
461 BATTERY_HILOGD(LABEL_TEST, "BatteryService022 start.");
462 ChargeType chargeType = g_service->GetChargeType();
463 EXPECT_TRUE(chargeType >= ChargeType::NONE && chargeType <= ChargeType::WIRELESS_SUPER_QUICK);
464 BATTERY_HILOGD(LABEL_TEST, "BatteryService022 end.");
465 }
466
467 /**
468 * @tc.name: BatteryService023
469 * @tc.desc: Test functions OnStop
470 * @tc.type: FUNC
471 */
472 static HWTEST_F(BatteryServiceTest, BatteryService023, TestSize.Level1)
473 {
474 BATTERY_HILOGD(LABEL_TEST, "BatteryService023 start.");
475 g_service->ready_ = true;
476 g_service->OnStop();
477 EXPECT_FALSE(g_service->ready_);
478
479 g_service->ready_ = true;
480 g_service->iBatteryInterface_ = nullptr;
481 g_service->hdiServiceMgr_ = nullptr;
482 g_service->OnStop();
483 EXPECT_FALSE(g_service->ready_);
484 g_service->OnStart();
485
486 BATTERY_HILOGD(LABEL_TEST, "BatteryService023 end.");
487 }
488