1 /*
2 * Copyright (c) 2021-2022 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_client_test.h"
17
18 #include <iostream>
19 #include <string>
20 #include <gtest/gtest.h>
21 #include "battery_log.h"
22 #include "battery_srv_client.h"
23 #include "test_utils.h"
24
25 using namespace testing::ext;
26 using namespace OHOS::PowerMgr;
27 using namespace OHOS;
28 using namespace std;
29
30 namespace {
31 bool g_isMock = false;
32 constexpr int32_t BATTERY_EMERGENCY_THRESHOLD = 5;
33 constexpr int32_t BATTERY_LOW_THRESHOLD = 20;
34 constexpr int32_t BATTERY_NORMAL_THRESHOLD = 90;
35 constexpr int32_t BATTERY_HIGH_THRESHOLD = 99;
36 constexpr int32_t BATTERY_HIGH_FULL = 100;
37 const std::string MOCK_BATTERY_PATH = "/data/service/el0/battery/";
38 }
39
SetUpTestCase(void)40 void BatteryClientTest::SetUpTestCase(void)
41 {
42 g_isMock = TestUtils::IsMock();
43 GTEST_LOG_(INFO) << " g_isMock: " << g_isMock;
44 }
45
TearDownTestCase(void)46 void BatteryClientTest::TearDownTestCase(void)
47 {
48 g_isMock = false;
49 TestUtils::ResetOnline();
50 }
51
SetUp(void)52 void BatteryClientTest::SetUp(void)
53 {
54 }
55
TearDown(void)56 void BatteryClientTest::TearDown(void)
57 {
58 }
59
60 namespace {
61 /**
62 * @tc.name: BatteryClient001
63 * @tc.desc: Test IBatterySrv interface GetCapacity
64 * @tc.type: FUNC
65 */
66 HWTEST_F (BatteryClientTest, BatteryClient001, TestSize.Level1)
67 {
68 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient001 start.");
69
70 auto& BatterySrvClient = BatterySrvClient::GetInstance();
71 if (g_isMock) {
72 auto tempCapacity = BatterySrvClient.GetCapacity();
73 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "22");
74 auto capacity = BatterySrvClient.GetCapacity();
75 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::capacity=%{public}d", capacity);
76 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient001 executing, capacity=" << capacity;
77 ASSERT_TRUE(capacity == 22);
78 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", std::to_string(tempCapacity));
79 } else {
80 auto capacity = BatterySrvClient.GetCapacity();
81 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::capacity=%{public}d", capacity);
82 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient001 executing, capacity=" << capacity;
83 ASSERT_TRUE(capacity <= 100 && capacity >= 0);
84 }
85
86 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient001 end.");
87 }
88
89 /**
90 * @tc.name: BatteryClient002
91 * @tc.desc: Test IBatterySrv interface GetChargingStatus
92 * @tc.type: FUNC
93 */
94
95 HWTEST_F (BatteryClientTest, BatteryClient002, TestSize.Level1)
96 {
97 auto& BatterySrvClient = BatterySrvClient::GetInstance();
98 if (g_isMock) {
99 auto tempChargeState = BatterySrvClient.GetChargingStatus();
100 std::string chargeStateArr[] = {"Discharging", "Charging", "Not charging", "Full", "Unknown"};
101
102 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status", "Not charging");
103 auto chargeState = BatterySrvClient.GetChargingStatus();
104 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::chargeState=%{public}d",
105 static_cast<int32_t>(chargeState));
106 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient002 executing, chargeState="
107 << static_cast<int32_t>(chargeState);
108 ASSERT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_DISABLE);
109
110 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/status",
111 chargeStateArr[static_cast<int32_t>(tempChargeState)]);
112 } else {
113 auto chargeState = BatterySrvClient.GetChargingStatus();
114 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::chargeState=%{public}d",
115 static_cast<int32_t>(chargeState));
116 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient002 executing, chargeState="
117 << static_cast<int32_t>(chargeState);
118 ASSERT_TRUE(chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_ENABLE ||
119 chargeState == OHOS::PowerMgr::BatteryChargeState::CHARGE_STATE_FULL);
120 }
121 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient002 end.");
122 }
123
124 /**
125 * @tc.name: BatteryClient003
126 * @tc.desc: Test IBatterySrv interface GetHealthStatus
127 * @tc.type: FUNC
128 */
129 HWTEST_F (BatteryClientTest, BatteryClient003, TestSize.Level1)
130 {
131 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient003 start.");
132 auto& BatterySrvClient = BatterySrvClient::GetInstance();
133 if (g_isMock) {
134 auto tempHealthState = BatterySrvClient.GetHealthStatus();
135 std::string healthStateArr[] = {"Unknown", "Good", "Hot", "Over voltage", "Cold", "Dead"};
136
137 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health", "Cold");
138 auto healthState = BatterySrvClient.GetHealthStatus();
139 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::healthState=%{public}d",
140 static_cast<int32_t>(healthState));
141 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient003 executing, healthState="
142 << static_cast<int32_t>(healthState);
143 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_COLD);
144
145 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/health",
146 healthStateArr[static_cast<int32_t>(tempHealthState)]);
147 } else {
148 auto healthState = BatterySrvClient.GetHealthStatus();
149 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::healthState=%{public}d",
150 static_cast<int32_t>(healthState));
151 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient003 executing, healthState="
152 << static_cast<int32_t>(healthState);
153 ASSERT_TRUE(healthState == OHOS::PowerMgr::BatteryHealthState::HEALTH_STATE_GOOD);
154 }
155 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient003 end.");
156 }
157
158 /**
159 * @tc.name: BatteryClient004
160 * @tc.desc: Test IBatterySrv interface GetPresent
161 * @tc.type: FUNC
162 */
163 HWTEST_F (BatteryClientTest, BatteryClient004, TestSize.Level1)
164 {
165 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient004 start.");
166 auto& BatterySrvClient = BatterySrvClient::GetInstance();
167 if (g_isMock) {
168 auto tempPresent = BatterySrvClient.GetPresent();
169 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", "0");
170 auto present = BatterySrvClient.GetPresent();
171 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::present=%{public}d", present);
172 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient004 executing, present=" << present;
173 ASSERT_FALSE(present);
174
175 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", std::to_string(tempPresent));
176 } else {
177 auto present = BatterySrvClient.GetPresent();
178 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::present=%{public}d", present);
179 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient004 executing, present=" << present;
180 ASSERT_TRUE(present);
181 }
182 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient004 end.");
183 }
184
185 /**
186 * @tc.name: BatteryClient005
187 * @tc.desc: Test IBatterySrv interface GetVoltage
188 * @tc.type: FUNC
189 */
190 HWTEST_F (BatteryClientTest, BatteryClient005, TestSize.Level1)
191 {
192 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient005 start.");
193 auto& BatterySrvClient = BatterySrvClient::GetInstance();
194 if (g_isMock) {
195 auto tempVoltage = BatterySrvClient.GetVoltage();
196 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", "4654321");
197 auto voltage = BatterySrvClient.GetVoltage();
198 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::voltage=%{public}d", voltage);
199 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient005 executing, voltage=" << voltage;
200 ASSERT_TRUE(voltage == 4654321);
201
202 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", std::to_string(tempVoltage));
203 } else {
204 auto voltage = BatterySrvClient.GetVoltage();
205 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::voltage=%{public}d", voltage);
206 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient005 executing, voltage=" << voltage;
207 ASSERT_TRUE(voltage >= 0);
208 }
209 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient005 end.");
210 }
211
212 /**
213 * @tc.name: BatteryClient006
214 * @tc.desc: Test IBatterySrv interface GetTemperature
215 * @tc.type: FUNC
216 */
217 HWTEST_F (BatteryClientTest, BatteryClient006, TestSize.Level1)
218 {
219 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient006 start.");
220 auto& BatterySrvClient = BatterySrvClient::GetInstance();
221 if (g_isMock) {
222 auto tempTempPresent = BatterySrvClient.GetBatteryTemperature();
223 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", "222");
224 auto temperature = BatterySrvClient.GetBatteryTemperature();
225 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::temperature=%{public}d", temperature);
226 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient006 executing, temperature=" << temperature;
227 ASSERT_TRUE(temperature == 222);
228
229 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", std::to_string(tempTempPresent));
230 } else {
231 auto temperature = BatterySrvClient.GetBatteryTemperature();
232 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::temperature=%{public}d", temperature);
233 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient006 executing, temperature=" << temperature;
234 ASSERT_TRUE(temperature >= 0 && temperature <= 600);
235 }
236 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient006 end.");
237 }
238
239 /**
240 * @tc.name: BatteryClient007
241 * @tc.desc: Test IBatterySrv interface GetTechnology
242 * @tc.type: FUNC
243 */
244 HWTEST_F (BatteryClientTest, BatteryClient007, TestSize.Level1)
245 {
246 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient007 start.");
247 auto& BatterySrvClient = BatterySrvClient::GetInstance();
248 if (g_isMock) {
249 std::string tempTechnology = BatterySrvClient.GetTechnology();
250 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos-fgu/technology", "H2");
251 auto technology = BatterySrvClient.GetTechnology();
252 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::technology=%{public}s", technology.c_str());
253 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient007 executing, technology=" << technology;
254 ASSERT_TRUE(technology == "H2");
255
256 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos-fgu/technology", tempTechnology);
257 } else {
258 auto technology = BatterySrvClient.GetTechnology();
259 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::technology=%{public}s", technology.c_str());
260 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient007 executing, technology=" << technology;
261 ASSERT_TRUE(technology == "Li-poly");
262 }
263 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient007 end.");
264 }
265
266 /**
267 * @tc.name: BatteryClient008
268 * @tc.desc: Test IBatterySrv interface GetPluggedType
269 * @tc.type: FUNC
270 */
271 HWTEST_F (BatteryClientTest, BatteryClient008, TestSize.Level1)
272 {
273 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient008 start.");
274 auto& BatterySrvClient = BatterySrvClient::GetInstance();
275 if (g_isMock) {
276 TestUtils::ResetOnline();
277 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/online", "1");
278 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/ohos_charger/type", "USB");
279 auto pluggedType = BatterySrvClient.GetPluggedType();
280
281 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::pluggedType=%{public}d",
282 static_cast<int32_t>(pluggedType));
283 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient008 executing, pluggedType="
284 << static_cast<int32_t>(pluggedType);
285
286 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_USB);
287 } else {
288 auto pluggedType = BatterySrvClient.GetPluggedType();
289 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::pluggedType=%{public}d",
290 static_cast<int32_t>(pluggedType));
291 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient008 executing, pluggedType="
292 << static_cast<int32_t>(pluggedType);
293 ASSERT_TRUE(pluggedType == OHOS::PowerMgr::BatteryPluggedType::PLUGGED_TYPE_USB);
294 }
295 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient008 end.");
296 }
297
298 /**
299 * @tc.name: BatteryClient009
300 * @tc.desc: Test IBatterySrv interface GetCurrentNow
301 * @tc.type: FUNC
302 */
303 HWTEST_F (BatteryClientTest, BatteryClient009, TestSize.Level1)
304 {
305 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient009 start.");
306 auto& BatterySrvClient = BatterySrvClient::GetInstance();
307 if (g_isMock) {
308 auto tempCurrnow = BatterySrvClient.GetNowCurrent();
309 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/current_now", "4654321");
310 auto currnow = BatterySrvClient.GetNowCurrent();
311 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::current=%{public}d", currnow);
312 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient009 executing, currnow=" << currnow;
313 ASSERT_EQ(currnow, 4654321);
314
315 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/current_now", std::to_string(tempCurrnow));
316 } else {
317 auto currnow = BatterySrvClient.GetNowCurrent();
318 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::currnow=%{public}d", currnow);
319 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient009 executing, currnow=" << currnow;
320 ASSERT_TRUE(currnow >= -20000 && currnow <= 20000);
321 }
322 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient009 end.");
323 }
324
325 /**
326 * @tc.name: BatteryClient010
327 * @tc.desc: Test IBatterySrv interface GetRemainEnergy
328 * @tc.type: FUNC
329 */
330 HWTEST_F (BatteryClientTest, BatteryClient010, TestSize.Level1)
331 {
332 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient010 start.");
333 auto& BatterySrvClient = BatterySrvClient::GetInstance();
334 if (g_isMock) {
335 auto tempChargenow = BatterySrvClient.GetRemainEnergy();
336 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/charge_now", "4654321");
337 auto chargenow = BatterySrvClient.GetRemainEnergy();
338 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::chargenow=%{public}d", chargenow);
339 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient010 executing, chargenow=" << chargenow;
340 ASSERT_EQ(chargenow, 4654321);
341
342 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/charge_now", std::to_string(tempChargenow));
343 } else {
344 auto chargenow = BatterySrvClient.GetRemainEnergy();
345 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::chargenow=%{public}d", chargenow);
346 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient010 executing, chargenow=" << chargenow;
347 ASSERT_TRUE(chargenow >= 0);
348 }
349 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient010 end.");
350 }
351
352 /**
353 * @tc.name: BatteryClient011
354 * @tc.desc: Test IBatterySrv interface GetTotalEnergy
355 * @tc.type: FUNC
356 */
357 HWTEST_F (BatteryClientTest, BatteryClient011, TestSize.Level1)
358 {
359 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient011 start.");
360 auto& BatterySrvClient = BatterySrvClient::GetInstance();
361 if (g_isMock) {
362 auto tempTotalenergy = BatterySrvClient.GetTotalEnergy();
363 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/charge_full", "4654321");
364 auto totalenergy = BatterySrvClient.GetTotalEnergy();
365 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::totalenergy=%{public}d", totalenergy);
366 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient011 executing, totalenergy=" << totalenergy;
367 ASSERT_EQ(totalenergy, 4654321);
368
369 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/charge_full", std::to_string(tempTotalenergy));
370 } else {
371 auto totalenergy = BatterySrvClient.GetTotalEnergy();
372 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::totalenergy=%{public}d", totalenergy);
373 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient011 executing, totalenergy=" << totalenergy;
374 ASSERT_TRUE(totalenergy >= 0);
375 }
376 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient011 end.");
377 }
378
379 /**
380 * @tc.name: BatteryClient012
381 * @tc.desc: Test IBatterySrv interface GetCapacityLevel
382 * @tc.type: FUNC
383 */
384 HWTEST_F (BatteryClientTest, BatteryClient012, TestSize.Level1)
385 {
386 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient012 start.");
387 auto& BatterySrvClient = BatterySrvClient::GetInstance();
388 if (g_isMock) {
389 auto tempCapacity = BatterySrvClient.GetCapacity();
390 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "3");
391 auto batterylevel = BatterySrvClient.GetCapacityLevel();
392 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
393 static_cast<int32_t>(batterylevel));
394 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient012 executing, batterylevel="
395 << static_cast<int32_t>(batterylevel);
396 ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_CRITICAL);
397
398 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", std::to_string(tempCapacity));
399 } else {
400 auto batterylevel = BatterySrvClient.GetCapacityLevel();
401 auto capacity = BatterySrvClient.GetCapacity();
402 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
403 static_cast<int32_t>(batterylevel));
404 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient012 executing, batterylevel="
405 << static_cast<int32_t>(batterylevel);
406 if (capacity < BATTERY_EMERGENCY_THRESHOLD) {
407 ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_CRITICAL);
408 }
409 }
410 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient012 end.");
411 }
412
413 /**
414 * @tc.name: BatteryClient013
415 * @tc.desc: Test IBatterySrv interface GetCapacityLevel
416 * @tc.type: FUNC
417 */
418 HWTEST_F (BatteryClientTest, BatteryClient013, TestSize.Level1)
419 {
420 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient013 start.");
421 auto& BatterySrvClient = BatterySrvClient::GetInstance();
422 if (g_isMock) {
423 auto tempCapacity = BatterySrvClient.GetCapacity();
424 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "11");
425 auto batterylevel = BatterySrvClient.GetCapacityLevel();
426 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
427 static_cast<int32_t>(batterylevel));
428 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient013 executing, batterylevel="
429 << static_cast<int32_t>(batterylevel);
430 ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_LOW);
431
432 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", std::to_string(tempCapacity));
433 } else {
434 auto batterylevel = BatterySrvClient.GetCapacityLevel();
435 auto capacity = BatterySrvClient.GetCapacity();
436 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
437 static_cast<int32_t>(batterylevel));
438 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient013 executing, batterylevel="
439 << static_cast<int32_t>(batterylevel);
440 if (capacity >= BATTERY_EMERGENCY_THRESHOLD && capacity <= BATTERY_LOW_THRESHOLD) {
441 ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_LOW);
442 }
443 }
444 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient013 end.");
445 }
446
447 /**
448 * @tc.name: BatteryClient014
449 * @tc.desc: Test IBatterySrv interface GetCapacityLevel
450 * @tc.type: FUNC
451 */
452 HWTEST_F (BatteryClientTest, BatteryClient014, TestSize.Level1)
453 {
454 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient014 start.");
455 auto& BatterySrvClient = BatterySrvClient::GetInstance();
456 if (g_isMock) {
457 auto tempCapacity = BatterySrvClient.GetCapacity();
458 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "80");
459 auto batterylevel = BatterySrvClient.GetCapacityLevel();
460 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
461 static_cast<int32_t>(batterylevel));
462 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient014 executing, batterylevel="
463 << static_cast<int32_t>(batterylevel);
464 ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_NORMAL);
465
466 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", std::to_string(tempCapacity));
467 } else {
468 auto batterylevel = BatterySrvClient.GetCapacityLevel();
469 auto capacity = BatterySrvClient.GetCapacity();
470 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
471 static_cast<int32_t>(batterylevel));
472 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient014 executing, batterylevel="
473 << static_cast<int32_t>(batterylevel);
474 if (capacity > BATTERY_LOW_THRESHOLD && capacity <= BATTERY_NORMAL_THRESHOLD) {
475 ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_NORMAL);
476 }
477 }
478 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient014 end.");
479 }
480
481 /**
482 * @tc.name: BatteryClient015
483 * @tc.desc: Test IBatterySrv interface GetCapacityLevel
484 * @tc.type: FUNC
485 */
486 HWTEST_F (BatteryClientTest, BatteryClient015, TestSize.Level1)
487 {
488 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient015 start.");
489 auto& BatterySrvClient = BatterySrvClient::GetInstance();
490 if (g_isMock) {
491 auto tempCapacity = BatterySrvClient.GetCapacity();
492 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "94");
493 auto batterylevel = BatterySrvClient.GetCapacityLevel();
494 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
495 static_cast<int32_t>(batterylevel));
496 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient015 executing, batterylevel="
497 << static_cast<int32_t>(batterylevel);
498 ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_HIGH);
499
500 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", std::to_string(tempCapacity));
501 } else {
502 auto batterylevel = BatterySrvClient.GetCapacityLevel();
503 auto capacity = BatterySrvClient.GetCapacity();
504 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
505 static_cast<int32_t>(batterylevel));
506 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient015 executing, batterylevel="
507 << static_cast<int32_t>(batterylevel);
508 if (capacity > BATTERY_NORMAL_THRESHOLD && capacity <= BATTERY_HIGH_THRESHOLD) {
509 ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_HIGH);
510 }
511 }
512 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient015 end.");
513 }
514
515 /**
516 * @tc.name: BatteryClient016
517 * @tc.desc: Test IBatterySrv interface GetCapacityLevel
518 * @tc.type: FUNC
519 */
520 HWTEST_F (BatteryClientTest, BatteryClient016, TestSize.Level1)
521 {
522 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient016 start.");
523 auto& BatterySrvClient = BatterySrvClient::GetInstance();
524 if (g_isMock) {
525 auto tempCapacity = BatterySrvClient.GetCapacity();
526 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "100");
527 auto batterylevel = BatterySrvClient.GetCapacityLevel();
528 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
529 static_cast<int32_t>(batterylevel));
530 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient016 executing, batterylevel="
531 << static_cast<int32_t>(batterylevel);
532 ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_FULL);
533
534 TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", std::to_string(tempCapacity));
535 } else {
536 auto batterylevel = BatterySrvClient.GetCapacityLevel();
537 auto capacity = BatterySrvClient.GetCapacity();
538 BATTERY_HILOGI(LABEL_TEST, "BatteryClientTest::batterylevel=%{public}d",
539 static_cast<int32_t>(batterylevel));
540 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient016 executing, batterylevel="
541 << static_cast<int32_t>(batterylevel);
542 if (capacity == BATTERY_HIGH_FULL) {
543 ASSERT_TRUE(batterylevel == OHOS::PowerMgr::BatteryCapacityLevel::LEVEL_FULL);
544 }
545 }
546 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient016 end.");
547 }
548
549
550 /**
551 * @tc.name: BatteryClient017
552 * @tc.desc: Test IBatterySrv interface GetRemainingChargeTime
553 * @tc.type: FUNC
554 */
555 HWTEST_F (BatteryClientTest, BatteryClient017, TestSize.Level1)
556 {
557 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient017 start.");
558 auto& BatterySrvClient = BatterySrvClient::GetInstance();
559 if (g_isMock) {
560 auto remainingChargeTime = BatterySrvClient.GetRemainingChargeTime();
561 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient017 executing, remainingChargeTime=" << remainingChargeTime;
562 ASSERT_TRUE(remainingChargeTime >= 0);
563 } else {
564 auto remainingChargeTime = BatterySrvClient.GetRemainingChargeTime();
565 GTEST_LOG_(INFO) << "BatteryClient::BatteryClient017 executing, remainingChargeTime=" << remainingChargeTime;
566 ASSERT_TRUE(remainingChargeTime >= 0);
567 }
568 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient017 end.");
569 }
570
571 /**
572 * @tc.name: BatteryClient018
573 * @tc.desc: Test BatteryInfo operator== and operator!=
574 * @tc.type: FUNC
575 */
576 HWTEST_F (BatteryClientTest, BatteryClient018, TestSize.Level1)
577 {
578 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient018 start.");
579 BatteryInfo info1;
580 BatteryInfo info2;
581 ASSERT_TRUE(info1 == info2);
582
583 info1.SetCapacity(100);
584 info2.SetCapacity(0);
585 ASSERT_TRUE(info1 != info2);
586
587 BATTERY_HILOGD(LABEL_TEST, "BatteryClient::BatteryClient018 end.");
588 }
589 }