1 /*
2 * Copyright (c) 2022-2024 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_notify_test.h"
17
18 #include <string>
19
20 #include "battery_log.h"
21 #include "battery_notify.h"
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace PowerMgr {
26 BatteryInfo* g_batteryInfo;
27 std::shared_ptr<BatteryNotify> g_batteryNotify;
28
SetUpTestCase()29 void BatteryNotifyTest::SetUpTestCase()
30 {
31 g_batteryNotify = std::make_shared<BatteryNotify>();
32 }
33
SetUp()34 void BatteryNotifyTest::SetUp()
35 {
36 g_batteryInfo = new BatteryInfo();
37 const int32_t capacity = 100;
38 g_batteryInfo->SetCapacity(capacity);
39 const int32_t voltage = 1;
40 g_batteryInfo->SetVoltage(voltage);
41 const int32_t temperature = 25;
42 g_batteryInfo->SetTemperature(temperature);
43 const BatteryHealthState healthState = BatteryHealthState::HEALTH_STATE_UNKNOWN;
44 g_batteryInfo->SetHealthState(healthState);
45 const BatteryPluggedType pluggedType = BatteryPluggedType::PLUGGED_TYPE_NONE;
46 g_batteryInfo->SetPluggedType(pluggedType);
47 const int32_t plugMaxCur = 50;
48 g_batteryInfo->SetPluggedMaxCurrent(plugMaxCur);
49 const int32_t plugMaxVol = 50;
50 g_batteryInfo->SetPluggedMaxVoltage(plugMaxVol);
51 const BatteryChargeState chargeState = BatteryChargeState::CHARGE_STATE_NONE;
52 g_batteryInfo->SetChargeState(chargeState);
53 const int32_t chargeCounter = 1;
54 g_batteryInfo->SetChargeCounter(chargeCounter);
55 const int32_t totalEnergy = 50;
56 g_batteryInfo->SetTotalEnergy(totalEnergy);
57 const int32_t curAverage = 10;
58 g_batteryInfo->SetCurAverage(curAverage);
59 const int32_t remainEnergy = 30;
60 g_batteryInfo->SetRemainEnergy(remainEnergy);
61 g_batteryInfo->SetPresent(true);
62 const string tec = "H2";
63 g_batteryInfo->SetTechnology(tec);
64 const int32_t nowCur = 10;
65 g_batteryInfo->SetNowCurrent(nowCur);
66 }
67
TearDown()68 void BatteryNotifyTest::TearDown()
69 {
70 if (g_batteryInfo != nullptr) {
71 delete g_batteryInfo;
72 g_batteryInfo = nullptr;
73 }
74 }
75
76 /**
77 * @tc.name: BatteryNotify001
78 * @tc.desc: Test PublishEvents
79 * @tc.type: FUNC
80 * @tc.require: issueI5YZR1
81 */
HWTEST_F(BatteryNotifyTest, BatteryNotify001, TestSize.Level1)82 HWTEST_F(BatteryNotifyTest, BatteryNotify001, TestSize.Level1)
83 {
84 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify001 begin");
85 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
86 EXPECT_EQ(ret, ERR_OK);
87 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify001 end");
88 }
89
90 /**
91 * @tc.name: BatteryNotify002
92 * @tc.desc: Test PublishEvents
93 * @tc.type: FUNC
94 * @tc.require: issueI5YZR1
95 */
HWTEST_F(BatteryNotifyTest, BatteryNotify002, TestSize.Level1)96 HWTEST_F(BatteryNotifyTest, BatteryNotify002, TestSize.Level1)
97 {
98 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify002 begin");
99 const BatteryHealthState healthState = BatteryHealthState::HEALTH_STATE_GOOD;
100 g_batteryInfo->SetHealthState(healthState);
101 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
102 EXPECT_EQ(ret, ERR_OK);
103 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify002 end");
104 }
105
106 /**
107 * @tc.name: BatteryNotify003
108 * @tc.desc: Test PublishEvents
109 * @tc.type: FUNC
110 * @tc.require: issueI5YZR1
111 */
HWTEST_F(BatteryNotifyTest, BatteryNotify003, TestSize.Level1)112 HWTEST_F(BatteryNotifyTest, BatteryNotify003, TestSize.Level1)
113 {
114 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify003 begin");
115 const BatteryHealthState healthState = BatteryHealthState::HEALTH_STATE_OVERHEAT;
116 g_batteryInfo->SetHealthState(healthState);
117 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
118 EXPECT_EQ(ret, ERR_OK);
119 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify003 end");
120 }
121
122 /**
123 * @tc.name: BatteryNotify004
124 * @tc.desc: Test PublishEvents
125 * @tc.type: FUNC
126 * @tc.require: issueI5YZR1
127 */
HWTEST_F(BatteryNotifyTest, BatteryNotify004, TestSize.Level1)128 HWTEST_F(BatteryNotifyTest, BatteryNotify004, TestSize.Level1)
129 {
130 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify004 begin");
131 const BatteryHealthState healthState = BatteryHealthState::HEALTH_STATE_OVERVOLTAGE;
132 g_batteryInfo->SetHealthState(healthState);
133 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
134 EXPECT_EQ(ret, ERR_OK);
135 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify004 end");
136 }
137
138 /**
139 * @tc.name: BatteryNotify005
140 * @tc.desc: Test PublishEvents
141 * @tc.type: FUNC
142 * @tc.require: issueI5YZR1
143 */
HWTEST_F(BatteryNotifyTest, BatteryNotify005, TestSize.Level1)144 HWTEST_F(BatteryNotifyTest, BatteryNotify005, TestSize.Level1)
145 {
146 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify005 begin");
147 const BatteryHealthState healthState = BatteryHealthState::HEALTH_STATE_COLD;
148 g_batteryInfo->SetHealthState(healthState);
149 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
150 EXPECT_EQ(ret, ERR_OK);
151 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify005 end");
152 }
153
154 /**
155 * @tc.name: BatteryNotify006
156 * @tc.desc: Test PublishEvents
157 * @tc.type: FUNC
158 * @tc.require: issueI5YZR1
159 */
HWTEST_F(BatteryNotifyTest, BatteryNotify006, TestSize.Level1)160 HWTEST_F(BatteryNotifyTest, BatteryNotify006, TestSize.Level1)
161 {
162 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify006 begin");
163 const BatteryHealthState healthState = BatteryHealthState::HEALTH_STATE_DEAD;
164 g_batteryInfo->SetHealthState(healthState);
165 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
166 EXPECT_EQ(ret, ERR_OK);
167 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify006 end");
168 }
169
170 /**
171 * @tc.name: BatteryNotify007
172 * @tc.desc: Test PublishEvents
173 * @tc.type: FUNC
174 * @tc.require: issueI5YZR1
175 */
HWTEST_F(BatteryNotifyTest, BatteryNotify007, TestSize.Level1)176 HWTEST_F(BatteryNotifyTest, BatteryNotify007, TestSize.Level1)
177 {
178 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify007 begin");
179 const BatteryHealthState healthState = BatteryHealthState::HEALTH_STATE_BUTT;
180 g_batteryInfo->SetHealthState(healthState);
181 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
182 EXPECT_EQ(ret, ERR_OK);
183 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify007 end");
184 }
185
186 /**
187 * @tc.name: BatteryNotify008
188 * @tc.desc: Test PublishEvents
189 * @tc.type: FUNC
190 * @tc.require: issueI5YZR1
191 */
HWTEST_F(BatteryNotifyTest, BatteryNotify008, TestSize.Level1)192 HWTEST_F(BatteryNotifyTest, BatteryNotify008, TestSize.Level1)
193 {
194 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify008 begin");
195 const BatteryPluggedType pluggedType = BatteryPluggedType::PLUGGED_TYPE_NONE;
196 g_batteryInfo->SetPluggedType(pluggedType);
197 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
198 EXPECT_EQ(ret, ERR_OK);
199 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify008 end");
200 }
201
202 /**
203 * @tc.name: BatteryNotify009
204 * @tc.desc: Test PublishEvents
205 * @tc.type: FUNC
206 * @tc.require: issueI5YZR1
207 */
HWTEST_F(BatteryNotifyTest, BatteryNotify009, TestSize.Level1)208 HWTEST_F(BatteryNotifyTest, BatteryNotify009, TestSize.Level1)
209 {
210 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify009 begin");
211 const BatteryPluggedType pluggedType = BatteryPluggedType::PLUGGED_TYPE_AC;
212 g_batteryInfo->SetPluggedType(pluggedType);
213 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
214 EXPECT_EQ(ret, ERR_OK);
215 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify009 end");
216 }
217
218 /**
219 * @tc.name: BatteryNotify010
220 * @tc.desc: Test PublishEvents
221 * @tc.type: FUNC
222 * @tc.require: issueI5YZR1
223 */
HWTEST_F(BatteryNotifyTest, BatteryNotify010, TestSize.Level1)224 HWTEST_F(BatteryNotifyTest, BatteryNotify010, TestSize.Level1)
225 {
226 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify010 begin");
227 const BatteryPluggedType pluggedType = BatteryPluggedType::PLUGGED_TYPE_USB;
228 g_batteryInfo->SetPluggedType(pluggedType);
229 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
230 EXPECT_EQ(ret, ERR_OK);
231 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify010 end");
232 }
233
234 /**
235 * @tc.name: BatteryNotify011
236 * @tc.desc: Test PublishEvents
237 * @tc.type: FUNC
238 * @tc.require: issueI5YZR1
239 */
HWTEST_F(BatteryNotifyTest, BatteryNotify011, TestSize.Level1)240 HWTEST_F(BatteryNotifyTest, BatteryNotify011, TestSize.Level1)
241 {
242 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify011 begin");
243 const BatteryPluggedType pluggedType = BatteryPluggedType::PLUGGED_TYPE_WIRELESS;
244 g_batteryInfo->SetPluggedType(pluggedType);
245 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
246 EXPECT_EQ(ret, ERR_OK);
247 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify011 end");
248 }
249
250 /**
251 * @tc.name: BatteryNotify012
252 * @tc.desc: Test PublishEvents
253 * @tc.type: FUNC
254 * @tc.require: issueI5YZR1
255 */
HWTEST_F(BatteryNotifyTest, BatteryNotify012, TestSize.Level1)256 HWTEST_F(BatteryNotifyTest, BatteryNotify012, TestSize.Level1)
257 {
258 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify012 begin");
259 const BatteryPluggedType pluggedType = BatteryPluggedType::PLUGGED_TYPE_BUTT;
260 g_batteryInfo->SetPluggedType(pluggedType);
261 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
262 EXPECT_EQ(ret, ERR_OK);
263 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify012 end");
264 }
265
266 /**
267 * @tc.name: BatteryNotify013
268 * @tc.desc: Test PublishEvents
269 * @tc.type: FUNC
270 * @tc.require: issueI5YZR1
271 */
HWTEST_F(BatteryNotifyTest, BatteryNotify013, TestSize.Level1)272 HWTEST_F(BatteryNotifyTest, BatteryNotify013, TestSize.Level1)
273 {
274 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify013 begin");
275 const BatteryChargeState chargeState = BatteryChargeState::CHARGE_STATE_ENABLE;
276 g_batteryInfo->SetChargeState(chargeState);
277 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
278 EXPECT_EQ(ret, ERR_OK);
279 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify013 end");
280 }
281
282 /**
283 * @tc.name: BatteryNotify014
284 * @tc.desc: Test PublishEvents
285 * @tc.type: FUNC
286 * @tc.require: issueI5YZR1
287 */
HWTEST_F(BatteryNotifyTest, BatteryNotify014, TestSize.Level1)288 HWTEST_F(BatteryNotifyTest, BatteryNotify014, TestSize.Level1)
289 {
290 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify014 begin");
291 const BatteryChargeState chargeState = BatteryChargeState::CHARGE_STATE_DISABLE;
292 g_batteryInfo->SetChargeState(chargeState);
293 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
294 EXPECT_EQ(ret, ERR_OK);
295 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify014 end");
296 }
297
298 /**
299 * @tc.name: BatteryNotify015
300 * @tc.desc: Test PublishEvents
301 * @tc.type: FUNC
302 * @tc.require: issueI5YZR1
303 */
HWTEST_F(BatteryNotifyTest, BatteryNotify015, TestSize.Level1)304 HWTEST_F(BatteryNotifyTest, BatteryNotify015, TestSize.Level1)
305 {
306 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify015 begin");
307 const BatteryChargeState chargeState = BatteryChargeState::CHARGE_STATE_FULL;
308 g_batteryInfo->SetChargeState(chargeState);
309 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
310 EXPECT_EQ(ret, ERR_OK);
311 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify015 end");
312 }
313
314 /**
315 * @tc.name: BatteryNotify016
316 * @tc.desc: Test PublishEvents
317 * @tc.type: FUNC
318 * @tc.require: issueI5YZR1
319 */
HWTEST_F(BatteryNotifyTest, BatteryNotify016, TestSize.Level1)320 HWTEST_F(BatteryNotifyTest, BatteryNotify016, TestSize.Level1)
321 {
322 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify016 begin");
323 const BatteryChargeState chargeState = BatteryChargeState::CHARGE_STATE_BUTT;
324 g_batteryInfo->SetChargeState(chargeState);
325 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
326 EXPECT_EQ(ret, ERR_OK);
327 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify016 end");
328 }
329
330 /**
331 * @tc.name: BatteryNotify017
332 * @tc.desc: Test PublishEvents
333 * @tc.type: FUNC
334 * @tc.require: issueI5YZR1
335 */
HWTEST_F(BatteryNotifyTest, BatteryNotify017, TestSize.Level1)336 HWTEST_F(BatteryNotifyTest, BatteryNotify017, TestSize.Level1)
337 {
338 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify017 begin");
339 const int32_t capacity = -100;
340 g_batteryInfo->SetCapacity(capacity);
341 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
342 EXPECT_EQ(ret, ERR_OK);
343 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify017 end");
344 }
345
346 /**
347 * @tc.name: BatteryNotify018
348 * @tc.desc: Test PublishEvents
349 * @tc.type: FUNC
350 * @tc.require: issueI5YZR1
351 */
HWTEST_F(BatteryNotifyTest, BatteryNotify018, TestSize.Level1)352 HWTEST_F(BatteryNotifyTest, BatteryNotify018, TestSize.Level1)
353 {
354 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify018 begin");
355 for (int i = 0; i < 2; i++) {
356 const BatteryChargeState chargeState = BatteryChargeState::CHARGE_STATE_ENABLE;
357 g_batteryInfo->SetChargeState(chargeState);
358 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
359 EXPECT_EQ(ret, ERR_OK);
360 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify018 end");
361 }
362 }
363
364 /**
365 * @tc.name: BatteryNotify019
366 * @tc.desc: Test PublishEvents
367 * @tc.type: FUNC
368 * @tc.require: issueI5YZR1
369 */
HWTEST_F(BatteryNotifyTest, BatteryNotify019, TestSize.Level1)370 HWTEST_F(BatteryNotifyTest, BatteryNotify019, TestSize.Level1)
371 {
372 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify019 begin");
373 const int32_t capacity = -100;
374 g_batteryInfo->SetCapacity(capacity);
375 for (int i = 0; i < 2; i++) {
376 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
377 EXPECT_EQ(ret, ERR_OK);
378 }
379 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify019 end");
380 }
381
382 /**
383 * @tc.name: BatteryNotify020
384 * @tc.desc: Test PublishChargeTypeEvent
385 * @tc.type: FUNC
386 */
HWTEST_F(BatteryNotifyTest, BatteryNotify020, TestSize.Level1)387 HWTEST_F(BatteryNotifyTest, BatteryNotify020, TestSize.Level1)
388 {
389 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify020 begin");
390 const ChargeType chargeType = ChargeType::WIRED_NORMAL;
391 g_batteryInfo->SetChargeType(chargeType);
392 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
393 EXPECT_EQ(ret, ERR_OK);
394 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify020 end");
395 }
396
397 /**
398 * @tc.name: BatteryNotify021
399 * @tc.desc: Test PublishUEvent
400 * @tc.type: FUNC
401 */
HWTEST_F(BatteryNotifyTest, BatteryNotify021, TestSize.Level1)402 HWTEST_F(BatteryNotifyTest, BatteryNotify021, TestSize.Level1)
403 {
404 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify021 begin");
405 const string uevent1 = "TEST_BATTERY_UNDER_VOLTAGE=3";
406 g_batteryInfo->SetUevent(uevent1);
407 EXPECT_EQ(g_batteryInfo->GetUevent(), uevent1);
408
409 const string uevent2 = "BATTERY_UNDER_VOLTAGE=3";
410 g_batteryInfo->SetUevent(uevent2);
411 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
412 EXPECT_EQ(ret, ERR_OK);
413
414 const string uevent3 = "XXXBATTERY_UNDER_VOLTAGE=1";
415 g_batteryInfo->SetUevent(uevent3);
416 ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
417 EXPECT_EQ(ret, ERR_OK);
418 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify021 end");
419 }
420 } // namespace PowerMgr
421 } // namespace OHOS
422