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_notify_test.h"
17
18 #include <string>
19 #ifdef GTEST
20 #define private public
21 #define protected public
22 #endif
23
24 #include "battery_log.h"
25 #include "battery_notify.h"
26 #include "battery_service.h"
27 #include "battery_config.h"
28 #ifdef BATTERY_MANAGER_ENABLE_CHARGING_SOUND
29 #include "charging_sound.h"
30 #include "ffrt_utils.h"
31 #endif
32 #include "notification_locale.h"
33 using namespace testing::ext;
34
35 namespace OHOS {
36 namespace PowerMgr {
37 namespace {
38 #ifdef BATTERY_MANAGER_ENABLE_CHARGING_SOUND
39 bool g_retval = false;
40 bool g_called = false;
41 #endif
42 } // namespace
43 BatteryInfo* g_batteryInfo;
44 std::shared_ptr<BatteryNotify> g_batteryNotify;
45 sptr<BatteryService> g_service = DelayedSpSingleton<BatteryService>::GetInstance();
46
SetUpTestCase()47 void BatteryNotifyTest::SetUpTestCase()
48 {
49 g_batteryNotify = std::make_shared<BatteryNotify>();
50 }
51
SetUp()52 void BatteryNotifyTest::SetUp()
53 {
54 g_batteryInfo = new BatteryInfo();
55 const int32_t capacity = 100;
56 g_batteryInfo->SetCapacity(capacity);
57 const int32_t voltage = 1;
58 g_batteryInfo->SetVoltage(voltage);
59 const int32_t temperature = 25;
60 g_batteryInfo->SetTemperature(temperature);
61 const BatteryHealthState healthState = BatteryHealthState::HEALTH_STATE_UNKNOWN;
62 g_batteryInfo->SetHealthState(healthState);
63 const BatteryPluggedType pluggedType = BatteryPluggedType::PLUGGED_TYPE_NONE;
64 g_batteryInfo->SetPluggedType(pluggedType);
65 const int32_t plugMaxCur = 50;
66 g_batteryInfo->SetPluggedMaxCurrent(plugMaxCur);
67 const int32_t plugMaxVol = 50;
68 g_batteryInfo->SetPluggedMaxVoltage(plugMaxVol);
69 const BatteryChargeState chargeState = BatteryChargeState::CHARGE_STATE_NONE;
70 g_batteryInfo->SetChargeState(chargeState);
71 const int32_t chargeCounter = 1;
72 g_batteryInfo->SetChargeCounter(chargeCounter);
73 const int32_t totalEnergy = 50;
74 g_batteryInfo->SetTotalEnergy(totalEnergy);
75 const int32_t curAverage = 10;
76 g_batteryInfo->SetCurAverage(curAverage);
77 const int32_t remainEnergy = 30;
78 g_batteryInfo->SetRemainEnergy(remainEnergy);
79 g_batteryInfo->SetPresent(true);
80 const string tec = "H2";
81 g_batteryInfo->SetTechnology(tec);
82 const int32_t nowCur = 10;
83 g_batteryInfo->SetNowCurrent(nowCur);
84 const string uevent = "BatteryNotifyTest";
85 g_batteryInfo->SetUevent(uevent);
86 }
87
TearDown()88 void BatteryNotifyTest::TearDown()
89 {
90 if (g_batteryInfo != nullptr) {
91 delete g_batteryInfo;
92 g_batteryInfo = nullptr;
93 }
94 }
95
DestroyJsonValue(cJSON * & value)96 void BatteryNotifyTest::DestroyJsonValue(cJSON*& value)
97 {
98 if (value) {
99 cJSON_Delete(value);
100 value = nullptr;
101 }
102 }
103
104 #ifdef BATTERY_MANAGER_ENABLE_CHARGING_SOUND
105 // the static member function may be inlined in the C API func be the compiler
106 // thus redefine the non-static one which can't be inlined out
Play()107 bool ChargingSound::Play()
108 {
109 BATTERY_HILOGI(LABEL_TEST, "mock function called");
110 g_called = true;
111 return g_retval;
112 }
113 #endif
114
115 /**
116 * @tc.name: BatteryNotify001
117 * @tc.desc: Test PublishEvents
118 * @tc.type: FUNC
119 * @tc.require: issueI5YZR1
120 */
121 HWTEST_F(BatteryNotifyTest, BatteryNotify001, TestSize.Level1)
122 {
123 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify001 function start!");
124 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
125 EXPECT_EQ(ret, ERR_OK);
126 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify001 function end!");
127 }
128
129 /**
130 * @tc.name: BatteryNotify002
131 * @tc.desc: Test PublishEvents
132 * @tc.type: FUNC
133 * @tc.require: issueI5YZR1
134 */
135 HWTEST_F(BatteryNotifyTest, BatteryNotify002, TestSize.Level1)
136 {
137 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify002 function start!");
138 const BatteryHealthState healthState = BatteryHealthState::HEALTH_STATE_GOOD;
139 g_batteryInfo->SetHealthState(healthState);
140 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
141 EXPECT_EQ(ret, ERR_OK);
142 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify002 function end!");
143 }
144
145 /**
146 * @tc.name: BatteryNotify003
147 * @tc.desc: Test PublishEvents
148 * @tc.type: FUNC
149 * @tc.require: issueI5YZR1
150 */
151 HWTEST_F(BatteryNotifyTest, BatteryNotify003, TestSize.Level1)
152 {
153 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify003 function start!");
154 const BatteryHealthState healthState = BatteryHealthState::HEALTH_STATE_OVERHEAT;
155 g_batteryInfo->SetHealthState(healthState);
156 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
157 EXPECT_EQ(ret, ERR_OK);
158 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify003 function end!");
159 }
160
161 /**
162 * @tc.name: BatteryNotify004
163 * @tc.desc: Test PublishEvents
164 * @tc.type: FUNC
165 * @tc.require: issueI5YZR1
166 */
167 HWTEST_F(BatteryNotifyTest, BatteryNotify004, TestSize.Level1)
168 {
169 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify004 function start!");
170 const BatteryHealthState healthState = BatteryHealthState::HEALTH_STATE_OVERVOLTAGE;
171 g_batteryInfo->SetHealthState(healthState);
172 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
173 EXPECT_EQ(ret, ERR_OK);
174 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify004 function end!");
175 }
176
177 /**
178 * @tc.name: BatteryNotify005
179 * @tc.desc: Test PublishEvents
180 * @tc.type: FUNC
181 * @tc.require: issueI5YZR1
182 */
183 HWTEST_F(BatteryNotifyTest, BatteryNotify005, TestSize.Level1)
184 {
185 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify005 function start!");
186 const BatteryHealthState healthState = BatteryHealthState::HEALTH_STATE_COLD;
187 g_batteryInfo->SetHealthState(healthState);
188 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
189 EXPECT_EQ(ret, ERR_OK);
190 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify005 function end!");
191 }
192
193 /**
194 * @tc.name: BatteryNotify006
195 * @tc.desc: Test PublishEvents
196 * @tc.type: FUNC
197 * @tc.require: issueI5YZR1
198 */
199 HWTEST_F(BatteryNotifyTest, BatteryNotify006, TestSize.Level1)
200 {
201 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify006 function start!");
202 const BatteryHealthState healthState = BatteryHealthState::HEALTH_STATE_DEAD;
203 g_batteryInfo->SetHealthState(healthState);
204 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
205 EXPECT_EQ(ret, ERR_OK);
206 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify006 function end!");
207 }
208
209 /**
210 * @tc.name: BatteryNotify007
211 * @tc.desc: Test PublishEvents
212 * @tc.type: FUNC
213 * @tc.require: issueI5YZR1
214 */
215 HWTEST_F(BatteryNotifyTest, BatteryNotify007, TestSize.Level1)
216 {
217 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify007 function start!");
218 const BatteryHealthState healthState = BatteryHealthState::HEALTH_STATE_BUTT;
219 g_batteryInfo->SetHealthState(healthState);
220 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
221 EXPECT_EQ(ret, ERR_OK);
222 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify007 function end!");
223 }
224
225 /**
226 * @tc.name: BatteryNotify008
227 * @tc.desc: Test PublishEvents
228 * @tc.type: FUNC
229 * @tc.require: issueI5YZR1
230 */
231 HWTEST_F(BatteryNotifyTest, BatteryNotify008, TestSize.Level1)
232 {
233 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify008 function start!");
234 const BatteryPluggedType pluggedType = BatteryPluggedType::PLUGGED_TYPE_NONE;
235 g_batteryInfo->SetPluggedType(pluggedType);
236 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
237 EXPECT_EQ(ret, ERR_OK);
238 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify008 function end!");
239 }
240
241 /**
242 * @tc.name: BatteryNotify009
243 * @tc.desc: Test PublishEvents
244 * @tc.type: FUNC
245 * @tc.require: issueI5YZR1
246 */
247 HWTEST_F(BatteryNotifyTest, BatteryNotify009, TestSize.Level1)
248 {
249 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify009 function start!");
250 const BatteryPluggedType pluggedType = BatteryPluggedType::PLUGGED_TYPE_AC;
251 g_batteryInfo->SetPluggedType(pluggedType);
252 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
253 EXPECT_EQ(ret, ERR_OK);
254 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify009 function end!");
255 }
256
257 /**
258 * @tc.name: BatteryNotify010
259 * @tc.desc: Test PublishEvents
260 * @tc.type: FUNC
261 * @tc.require: issueI5YZR1
262 */
263 HWTEST_F(BatteryNotifyTest, BatteryNotify010, TestSize.Level1)
264 {
265 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify010 function start!");
266 const BatteryPluggedType pluggedType = BatteryPluggedType::PLUGGED_TYPE_USB;
267 g_batteryInfo->SetPluggedType(pluggedType);
268 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
269 EXPECT_EQ(ret, ERR_OK);
270 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify010 function end!");
271 }
272
273 /**
274 * @tc.name: BatteryNotify011
275 * @tc.desc: Test PublishEvents
276 * @tc.type: FUNC
277 * @tc.require: issueI5YZR1
278 */
279 HWTEST_F(BatteryNotifyTest, BatteryNotify011, TestSize.Level1)
280 {
281 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify011 function start!");
282 const BatteryPluggedType pluggedType = BatteryPluggedType::PLUGGED_TYPE_WIRELESS;
283 g_batteryInfo->SetPluggedType(pluggedType);
284 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
285 EXPECT_EQ(ret, ERR_OK);
286 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify011 function end!");
287 }
288
289 /**
290 * @tc.name: BatteryNotify012
291 * @tc.desc: Test PublishEvents
292 * @tc.type: FUNC
293 * @tc.require: issueI5YZR1
294 */
295 HWTEST_F(BatteryNotifyTest, BatteryNotify012, TestSize.Level1)
296 {
297 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify012 function start!");
298 const BatteryPluggedType pluggedType = BatteryPluggedType::PLUGGED_TYPE_BUTT;
299 g_batteryInfo->SetPluggedType(pluggedType);
300 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
301 EXPECT_EQ(ret, ERR_OK);
302 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify012 function end!");
303 }
304
305 /**
306 * @tc.name: BatteryNotify013
307 * @tc.desc: Test PublishEvents
308 * @tc.type: FUNC
309 * @tc.require: issueI5YZR1
310 */
311 HWTEST_F(BatteryNotifyTest, BatteryNotify013, TestSize.Level1)
312 {
313 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify013 function start!");
314 const BatteryChargeState chargeState = BatteryChargeState::CHARGE_STATE_ENABLE;
315 g_batteryInfo->SetChargeState(chargeState);
316 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
317 EXPECT_EQ(ret, ERR_OK);
318 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify013 function end!");
319 }
320
321 /**
322 * @tc.name: BatteryNotify014
323 * @tc.desc: Test PublishEvents
324 * @tc.type: FUNC
325 * @tc.require: issueI5YZR1
326 */
327 HWTEST_F(BatteryNotifyTest, BatteryNotify014, TestSize.Level1)
328 {
329 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify014 function start!");
330 const BatteryChargeState chargeState = BatteryChargeState::CHARGE_STATE_DISABLE;
331 g_batteryInfo->SetChargeState(chargeState);
332 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
333 EXPECT_EQ(ret, ERR_OK);
334 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify014 function end!");
335 }
336
337 /**
338 * @tc.name: BatteryNotify015
339 * @tc.desc: Test PublishEvents
340 * @tc.type: FUNC
341 * @tc.require: issueI5YZR1
342 */
343 HWTEST_F(BatteryNotifyTest, BatteryNotify015, TestSize.Level1)
344 {
345 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify015 function start!");
346 const BatteryChargeState chargeState = BatteryChargeState::CHARGE_STATE_FULL;
347 g_batteryInfo->SetChargeState(chargeState);
348 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
349 EXPECT_EQ(ret, ERR_OK);
350 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify015 function end!");
351 }
352
353 /**
354 * @tc.name: BatteryNotify016
355 * @tc.desc: Test PublishEvents
356 * @tc.type: FUNC
357 * @tc.require: issueI5YZR1
358 */
359 HWTEST_F(BatteryNotifyTest, BatteryNotify016, TestSize.Level1)
360 {
361 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify016 function start!");
362 const BatteryChargeState chargeState = BatteryChargeState::CHARGE_STATE_BUTT;
363 g_batteryInfo->SetChargeState(chargeState);
364 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
365 EXPECT_EQ(ret, ERR_OK);
366 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify016 function end!");
367 }
368
369 /**
370 * @tc.name: BatteryNotify017
371 * @tc.desc: Test PublishEvents
372 * @tc.type: FUNC
373 * @tc.require: issueI5YZR1
374 */
375 HWTEST_F(BatteryNotifyTest, BatteryNotify017, TestSize.Level1)
376 {
377 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify017 function start!");
378 const int32_t capacity = -100;
379 g_batteryInfo->SetCapacity(capacity);
380 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
381 EXPECT_EQ(ret, ERR_OK);
382 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify017 function end!");
383 }
384
385 /**
386 * @tc.name: BatteryNotify018
387 * @tc.desc: Test PublishEvents
388 * @tc.type: FUNC
389 * @tc.require: issueI5YZR1
390 */
391 HWTEST_F(BatteryNotifyTest, BatteryNotify018, TestSize.Level1)
392 {
393 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify018 function start!");
394 for (int i = 0; i < 2; i++) {
395 const BatteryChargeState chargeState = BatteryChargeState::CHARGE_STATE_ENABLE;
396 g_batteryInfo->SetChargeState(chargeState);
397 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
398 EXPECT_EQ(ret, ERR_OK);
399 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify018 function end!");
400 }
401 }
402
403 /**
404 * @tc.name: BatteryNotify019
405 * @tc.desc: Test PublishEvents
406 * @tc.type: FUNC
407 * @tc.require: issueI5YZR1
408 */
409 HWTEST_F(BatteryNotifyTest, BatteryNotify019, TestSize.Level1)
410 {
411 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify019 function start!");
412 const int32_t capacity = -100;
413 g_batteryInfo->SetCapacity(capacity);
414 for (int i = 0; i < 2; i++) {
415 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
416 EXPECT_EQ(ret, ERR_OK);
417 }
418 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify019 function end!");
419 }
420
421 /**
422 * @tc.name: BatteryNotify020
423 * @tc.desc: Test PublishChargeTypeEvent
424 * @tc.type: FUNC
425 */
426 HWTEST_F(BatteryNotifyTest, BatteryNotify020, TestSize.Level1)
427 {
428 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify020 function start!");
429 const ChargeType chargeType = ChargeType::WIRED_NORMAL;
430 g_batteryInfo->SetChargeType(chargeType);
431 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
432 EXPECT_EQ(ret, ERR_OK);
433 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify020 function end!");
434 }
435
436 /**
437 * @tc.name: BatteryNotify021
438 * @tc.desc: Test PublishUEvent
439 * @tc.type: FUNC
440 */
441 HWTEST_F(BatteryNotifyTest, BatteryNotify021, TestSize.Level1)
442 {
443 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify021 function start!");
444 const string uevent1 = "TEST_BATTERY_UNDER_VOLTAGE=3";
445 g_batteryInfo->SetUevent(uevent1);
446 EXPECT_EQ(g_batteryInfo->GetUevent(), uevent1);
447
448 const string uevent2 = "BATTERY_UNDER_VOLTAGE=3";
449 g_batteryInfo->SetUevent(uevent2);
450 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
451 EXPECT_EQ(ret, ERR_OK);
452
453 const string uevent3 = "XXXBATTERY_UNDER_VOLTAGE=1";
454 g_batteryInfo->SetUevent(uevent3);
455 ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
456 EXPECT_EQ(ret, ERR_OK);
457 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify021 function end!");
458 }
459
460 /**
461 * @tc.name: BatteryNotify023
462 * @tc.desc: Test PublishChangedEvent--BatteryInfo::COMMON_EVENT_KEY_CAPACITY_LEVEL
463 * @tc.type: FUNC
464 */
465 HWTEST_F(BatteryNotifyTest, BatteryNotify023, TestSize.Level1)
466 {
467 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify023 function start!");
468 g_service->isMockCapacity_ = true;
469 g_service->batteryInfo_.SetCapacity(100);
470 g_service->InitConfig();
471 bool ret = g_batteryNotify->PublishChangedEvent(*g_batteryInfo);
472 EXPECT_TRUE(ret);
473 g_service->batteryInfo_.SetCapacity(50);
474 ret = g_batteryNotify->PublishChangedEvent(*g_batteryInfo);
475 EXPECT_TRUE(ret);
476 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify023 function end!");
477 }
478
479 /**
480 * @tc.name: BatteryNotify024
481 * @tc.desc: Test HandleNotification
482 * @tc.type: FUNC
483 */
484 HWTEST_F(BatteryNotifyTest, BatteryNotify024, TestSize.Level1)
485 {
486 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify024 function start!");
487 std::string jsonStr = R"({"popup": {"XXX": [{"name": 123}]}})";
488 cJSON* parseResult = cJSON_Parse(jsonStr.c_str());
489 EXPECT_TRUE(parseResult);
490 auto& batteryConfig = BatteryConfig::GetInstance();
491 batteryConfig.config_ = parseResult;
492 batteryConfig.ParsePopupConf();
493 EXPECT_TRUE(batteryConfig.popupConfig_.size() == 1);
494 bool ret = g_batteryNotify->HandleNotification("XXX");
495 BATTERY_HILOGI(LABEL_TEST, "HandleNotification ret[%d]", static_cast<int32_t>(ret));
496 #ifndef BATTERY_SUPPORT_NOTIFICATION
497 EXPECT_TRUE(ret);
498 #endif
499 DestroyJsonValue(batteryConfig.config_);
500 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify024 function end!");
501 }
502
503 /**
504 * @tc.name: BatteryNotify025
505 * @tc.desc: Test SaveJsonToMap
506 * @tc.type: FUNC
507 */
508 HWTEST_F(BatteryNotifyTest, BatteryNotify025, TestSize.Level1)
509 {
510 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify025 function start!");
511 auto& localeConfig = NotificationLocale::GetInstance();
512 std::unordered_map<std::string, std::string> stringMap;
513 std::string jsonStr = "mock data";
514 localeConfig.SaveJsonToMap(jsonStr, "", stringMap);
515 EXPECT_TRUE(stringMap.size() == 0);
516
517 jsonStr = R"(null)";
518 localeConfig.SaveJsonToMap(jsonStr, "", stringMap);
519 EXPECT_TRUE(stringMap.size() == 0);
520
521 jsonStr = R"([{"wirelesscharger": null}])";
522 localeConfig.SaveJsonToMap(jsonStr, "", stringMap);
523 EXPECT_TRUE(stringMap.size() == 0);
524
525 jsonStr = R"({"wirelesscharger": null})";
526 localeConfig.SaveJsonToMap(jsonStr, "", stringMap);
527 EXPECT_TRUE(stringMap.size() == 0);
528
529 jsonStr = R"({"string": null})";
530 localeConfig.SaveJsonToMap(jsonStr, "", stringMap);
531 EXPECT_TRUE(stringMap.size() == 0);
532
533 jsonStr = R"({"string": 1})";
534 localeConfig.SaveJsonToMap(jsonStr, "", stringMap);
535 EXPECT_TRUE(stringMap.size() == 0);
536
537 jsonStr = R"({"string": [{"name": ""},{"value": ""},{"name": 1,"value": ""}]})";
538 localeConfig.SaveJsonToMap(jsonStr, "", stringMap);
539 EXPECT_TRUE(stringMap.size() == 0);
540
541 jsonStr = R"({"string": [{"name": "","value": 1},{"name": "","value": ""}]})";
542 localeConfig.SaveJsonToMap(jsonStr, "", stringMap);
543 EXPECT_TRUE(stringMap.size() == 0);
544 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify025 function end!");
545 }
546
547 /**
548 * @tc.name: BatteryNotify026
549 * @tc.desc: Test Charger Sound
550 * @tc.type: FUNC
551 */
552 #ifdef BATTERY_MANAGER_ENABLE_CHARGING_SOUND
553 HWTEST_F(BatteryNotifyTest, BatteryNotify026, TestSize.Level1)
554 {
555 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify026 function start!");
556 DelayedSpSingleton<BatteryService>::GetInstance()->Init();
557 g_batteryInfo->SetUevent("");
558 for (bool retval : {true, false}) {
559 g_retval = retval;
560 BatteryPluggedType pluggedType = BatteryPluggedType::PLUGGED_TYPE_NONE;
561 g_batteryInfo->SetPluggedType(pluggedType);
562 auto ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
563 EXPECT_EQ(ret, ERR_OK);
564 pluggedType = BatteryPluggedType::PLUGGED_TYPE_AC;
565 g_batteryInfo->SetPluggedType(pluggedType);
566 ret = g_batteryNotify->PublishEvents(*g_batteryInfo);
567 EXPECT_EQ(ret, ERR_OK);
568 ffrt::wait();
569 }
570 EXPECT_TRUE(g_called);
571 BATTERY_HILOGI(LABEL_TEST, "BatteryNotify026 function end!");
572 ffrt::wait();
573 }
574 #endif
575 } // namespace PowerMgr
576 } // namespace OHOS
577