1 /*
2 * Copyright (c) 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 #include <cJSON.h>
16 #include <gtest/gtest.h>
17 #include "power_mgr_service.h"
18 #include "power_mode_policy.h"
19 #include "power_log.h"
20 #include "setting_helper.h"
21 #include "shutdown_dialog.h"
22 #include "vibrator_source_parser.h"
23 #include "wakeup_controller.h"
24 #include "wakeup_source_parser.h"
25
26 using namespace testing;
27 using namespace testing::ext;
28 using namespace OHOS::PowerMgr;
29 using namespace OHOS;
30 using namespace std;
31
32 class PowerConfigParseTest : public Test {
33 public:
SetUp()34 void SetUp() override
35 {
36 root_ = cJSON_CreateObject();
37 }
38
TearDown()39 void TearDown() override
40 {
41 cJSON_Delete(root_);
42 }
43
44 cJSON* root_;
45 };
SetSettingWakeupSources(const std::string & jsonConfig)46 void SettingHelper::SetSettingWakeupSources(const std::string& jsonConfig)
47 {
48 }
49
SavePowerModeRecoverMap(const std::string & jsonConfig)50 void SettingHelper::SavePowerModeRecoverMap(const std::string& jsonConfig)
51 {
52 }
53
54 namespace {
55 static sptr<PowerMgrService> g_service;
56 constexpr size_t NUMBER_ONE = 1;
57 constexpr size_t NUMBER_TWO = 2;
58 constexpr int KEY1 = 10;
59 constexpr int KEY2 = 20;
60 constexpr int KEY3 = 30;
61 constexpr int VALUE1 = 100;
62 constexpr int VALUE2 = 200;
63 constexpr int VALUE3 = 300;
64
65 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest001, TestSize.Level0)
66 {
67 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest001 function start!");
68 EXPECT_TRUE(root_);
69 cJSON_AddItemToObject(root_, "action", cJSON_CreateNumber(NUMBER_ONE));
70 cJSON_AddItemToObject(root_, "delayMs", cJSON_CreateNumber(NUMBER_TWO));
71
72 std::string key = "lid";
73 std::shared_ptr<SuspendSources> parseSources = std::make_shared<SuspendSources>();
74 bool result = SuspendSourceParser::ParseSourcesProc(parseSources, root_, key);
75
76 EXPECT_TRUE(result);
77 std::vector<SuspendSource> sources = parseSources->GetSourceList();
78 EXPECT_EQ(sources.size(), NUMBER_ONE);
79 EXPECT_EQ(sources[0].reason_, SuspendDeviceType::SUSPEND_DEVICE_REASON_LID);
80 EXPECT_EQ(sources[0].action_, NUMBER_ONE);
81 EXPECT_EQ(sources[0].delayMs_, NUMBER_TWO);
82 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest001 function end!");
83 }
84
85 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest002, TestSize.Level0)
86 {
87 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest002 function start!");
88 EXPECT_TRUE(root_);
89 cJSON* valueObj = cJSON_CreateNumber(NUMBER_TWO);
90 cJSON_AddItemToObject(root_, "action", valueObj);
91 std::string key = "lid";
92 std::shared_ptr<SuspendSources> parseSources = std::make_shared<SuspendSources>();
93 bool result = SuspendSourceParser::ParseSourcesProc(parseSources, root_, key);
94 EXPECT_TRUE(result);
95 std::vector<SuspendSource> sources = parseSources->GetSourceList();
96 EXPECT_EQ(sources.size(), NUMBER_ONE);
97 EXPECT_EQ(sources[0].reason_, SuspendDeviceType::SUSPEND_DEVICE_REASON_LID);
98 EXPECT_EQ(sources[0].action_, 0);
99 EXPECT_EQ(sources[0].delayMs_, 0);
100 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest002 function end!");
101 }
102
103 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest003, TestSize.Level0)
104 {
105 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest003 function start!");
106 EXPECT_TRUE(root_);
107 std::string key = "lid";
108 std::shared_ptr<SuspendSources> parseSources = std::make_shared<SuspendSources>();
109 bool result = SuspendSourceParser::ParseSourcesProc(parseSources, nullptr, key);
110 EXPECT_TRUE(result);
111 std::vector<SuspendSource> sources = parseSources->GetSourceList();
112 EXPECT_EQ(sources.size(), NUMBER_ONE);
113 EXPECT_EQ(sources[0].reason_, SuspendDeviceType::SUSPEND_DEVICE_REASON_LID);
114 EXPECT_EQ(sources[0].action_, 0);
115 EXPECT_EQ(sources[0].delayMs_, 0);
116 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest003 function end!");
117 }
118
119 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest004, TestSize.Level0)
120 {
121 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest004 function start!");
122 EXPECT_TRUE(root_);
123 cJSON_AddItemToObject(root_, "action", cJSON_CreateNumber(NUMBER_ONE));
124
125 std::string key = "lid";
126 std::shared_ptr<SuspendSources> parseSources = std::make_shared<SuspendSources>();
127 bool result = SuspendSourceParser::ParseSourcesProc(parseSources, root_, key);
128
129 EXPECT_TRUE(result);
130 std::vector<SuspendSource> sources = parseSources->GetSourceList();
131 EXPECT_EQ(sources.size(), NUMBER_ONE);
132 EXPECT_EQ(sources[0].reason_, SuspendDeviceType::SUSPEND_DEVICE_REASON_LID);
133 EXPECT_EQ(sources[0].action_, 0);
134 EXPECT_EQ(sources[0].delayMs_, 0);
135 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest004 function end!");
136 }
137
138 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest005, TestSize.Level0)
139 {
140 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest005 function start!");
141 EXPECT_TRUE(root_);
142 cJSON_AddItemToObject(root_, "delayMs", cJSON_CreateNumber(NUMBER_TWO));
143
144 std::string key = "lid";
145 std::shared_ptr<SuspendSources> parseSources = std::make_shared<SuspendSources>();
146 bool result = SuspendSourceParser::ParseSourcesProc(parseSources, root_, key);
147
148 EXPECT_TRUE(result);
149 std::vector<SuspendSource> sources = parseSources->GetSourceList();
150 EXPECT_EQ(sources.size(), NUMBER_ONE);
151 EXPECT_EQ(sources[0].reason_, SuspendDeviceType::SUSPEND_DEVICE_REASON_LID);
152 EXPECT_EQ(sources[0].action_, 0);
153 EXPECT_EQ(sources[0].delayMs_, 0);
154 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest005 function end!");
155 }
156
157 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest006, TestSize.Level0)
158 {
159 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest006 function start!");
160 EXPECT_TRUE(root_);
161 const std::string json = R"({"lid": {"action": 1, "delayMs": 2}})";
162 auto parseSources = SuspendSourceParser::ParseSources(json);
163 std::vector<SuspendSource> sources = parseSources->GetSourceList();
164 EXPECT_EQ(sources.size(), NUMBER_ONE);
165 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest006 function end!");
166 }
167
168 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest007, TestSize.Level0)
169 {
170 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest007 function start!");
171 EXPECT_TRUE(root_);
172 auto parseSources = SuspendSourceParser::ParseSources("");
173 std::vector<SuspendSource> sources = parseSources->GetSourceList();
174 EXPECT_EQ(sources.size(), 0);
175 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest007 function end!");
176 }
177
178 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest008, TestSize.Level0)
179 {
180 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest008 function start!");
181 EXPECT_TRUE(root_);
182 auto parseSources = SuspendSourceParser::ParseSources("[]");
183 std::vector<SuspendSource> sources = parseSources->GetSourceList();
184 EXPECT_EQ(sources.size(), 0);
185 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest008 function end!");
186 }
187
188 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest010, TestSize.Level0)
189 {
190 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest010 function start!");
191 EXPECT_TRUE(root_);
192 PowerModePolicy powerModePolicy;
193 powerModePolicy.InitRecoverMap();
194 std::string json = "";
195 bool ret = powerModePolicy.ParseRecoverJson(json);
196 EXPECT_FALSE(ret);
197 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest010 function end!");
198 }
199
200 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest011, TestSize.Level0)
201 {
202 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest011 function start!");
203 EXPECT_TRUE(root_);
204 PowerModePolicy powerModePolicy;
205 std::string json = R"("this is a string")";
206 bool ret = powerModePolicy.ParseRecoverJson(json);
207 EXPECT_FALSE(ret);
208 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest011 function end!");
209 }
210
211 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest012, TestSize.Level0)
212 {
213 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest012 function start!");
214 EXPECT_TRUE(root_);
215 PowerModePolicy powerModePolicy;
216 std::string json = R"({invalid:json)";
217 bool ret = powerModePolicy.ParseRecoverJson(json);
218 EXPECT_FALSE(ret);
219 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest012 function end!");
220 }
221
222 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest013, TestSize.Level0)
223 {
224 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest013 function start!");
225 EXPECT_TRUE(root_);
226 PowerModePolicy powerModePolicy;
227 std::string json = R"({"10": 100, "20": 200, "30": 300})";
228 bool ret = powerModePolicy.ParseRecoverJson(json);
229 EXPECT_TRUE(ret);
230 EXPECT_EQ(powerModePolicy.recoverMap_.size(), 3);
231 EXPECT_EQ(powerModePolicy.recoverMap_[KEY1], VALUE1);
232 EXPECT_EQ(powerModePolicy.recoverMap_[KEY2], VALUE2);
233 EXPECT_EQ(powerModePolicy.recoverMap_[KEY3], VALUE3);
234 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest013 function end!");
235 }
236
237 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest014, TestSize.Level0)
238 {
239 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest014 function start!");
240 EXPECT_TRUE(root_);
241 PowerModePolicy powerModePolicy;
242 std::string json = R"({"abc": 100, "10x": 200})";
243 bool ret = powerModePolicy.ParseRecoverJson(json);
244 EXPECT_TRUE(ret);
245 EXPECT_TRUE(powerModePolicy.recoverMap_.empty());
246 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest014 function end!");
247 }
248
249 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest015, TestSize.Level0)
250 {
251 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest015 function start!");
252 EXPECT_TRUE(root_);
253 PowerModePolicy powerModePolicy;
254 powerModePolicy.recoverMap_[10] = 20;
255 powerModePolicy.SavePowerModeRecoverMap();
256 std::string json = R"({"22222222222222222222222222": 100, "10x": 200})";
257 bool ret = powerModePolicy.ParseRecoverJson(json);
258 EXPECT_TRUE(ret);
259 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest015 function end!");
260 }
261
262 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest016, TestSize.Level0)
263 {
264 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest016 function start!");
265 EXPECT_TRUE(root_);
266 PowerModePolicy powerModePolicy;
267 std::string json = R"({"10": "100", "20": "200", "30": "300"})";
268 bool ret = powerModePolicy.ParseRecoverJson(json);
269 EXPECT_TRUE(ret);
270 EXPECT_TRUE(powerModePolicy.recoverMap_.empty());
271 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest016 function end!");
272 }
273
274 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest018, TestSize.Level0)
275 {
276 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest018 function start!");
277 EXPECT_TRUE(root_);
278 ShutdownDialog shutdownDialog;
279 shutdownDialog.LoadDialogConfig();
280 std::string json("");
281 shutdownDialog.ParseJsonConfig(json);
282 EXPECT_FALSE(shutdownDialog.bundleName_.empty());
283 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest018 function end!");
284 }
285
286 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest019, TestSize.Level0)
287 {
288 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest019 function start!");
289 EXPECT_TRUE(root_);
290 ShutdownDialog shutdownDialog;
291 std::string json("[]");
292 shutdownDialog.ParseJsonConfig(json);
293 EXPECT_FALSE(shutdownDialog.bundleName_.empty());
294 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest019 function end!");
295 }
296
297 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest020, TestSize.Level0)
298 {
299 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest020 function start!");
300 EXPECT_TRUE(root_);
301 ShutdownDialog shutdownDialog;
302 std::string json = R"({"uiExtensionType": "sysDialog/power"})";
303 shutdownDialog.ParseJsonConfig(json);
304 EXPECT_FALSE(shutdownDialog.bundleName_.empty());
305 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest020 function end!");
306 }
307
308 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest021, TestSize.Level0)
309 {
310 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest021 function start!");
311 EXPECT_TRUE(root_);
312 ShutdownDialog shutdownDialog;
313 std::string json = R"({"bundleName22": "test"})";
314 shutdownDialog.ParseJsonConfig(json);
315 EXPECT_FALSE(shutdownDialog.bundleName_.empty());
316 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest021 function end!");
317 }
318
319 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest022, TestSize.Level0)
320 {
321 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest022 function start!");
322 EXPECT_TRUE(root_);
323 ShutdownDialog shutdownDialog;
324 std::string json = R"({"bundleName": "com.ohos.powerdialog"})";
325 shutdownDialog.ParseJsonConfig(json);
326 EXPECT_FALSE(shutdownDialog.bundleName_.empty());
327 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest022 function end!");
328 }
329
330 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest023, TestSize.Level0)
331 {
332 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest023 function start!");
333 EXPECT_TRUE(root_);
334 ShutdownDialog shutdownDialog;
335 std::string json = R"({"abilityName": "PowerUiExtensionAbility"})";
336 shutdownDialog.ParseJsonConfig(json);
337 EXPECT_FALSE(shutdownDialog.bundleName_.empty());
338 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest023 function end!");
339 }
340
341 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest024, TestSize.Level0)
342 {
343 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest024 function start!");
344 EXPECT_TRUE(root_);
345 cJSON* array = cJSON_CreateArray();
346 cJSON_AddItemToObject(root_, "points", array);
347 std::string key = "lid";
348 std::shared_ptr<SuspendSources> parseSources = std::make_shared<SuspendSources>();
349 bool result = SuspendSourceParser::ParseSourcesProc(parseSources, array, key);
350
351 EXPECT_TRUE(result);
352 std::vector<SuspendSource> sources = parseSources->GetSourceList();
353 EXPECT_EQ(sources.size(), NUMBER_ONE);
354 EXPECT_EQ(sources[0].reason_, SuspendDeviceType::SUSPEND_DEVICE_REASON_LID);
355 EXPECT_EQ(sources[0].action_, 0);
356 EXPECT_EQ(sources[0].delayMs_, 0);
357 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest024 function end!");
358 }
359 #ifdef POWER_DOUBLECLICK_ENABLE
360 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest025, TestSize.Level0)
361 {
362 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest025 function start!");
363 EXPECT_TRUE(root_);
364 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
365 g_service->OnStart();
366 std::shared_ptr<PowerStateMachine> stateMachine = g_service->GetPowerStateMachine();
367 std::shared_ptr<WakeupController> wakeupController = std::make_shared<WakeupController>(stateMachine);
368 std::string json("");
369 EXPECT_TRUE(wakeupController != nullptr);
370 wakeupController->WakeupParseJsonConfig(true, json);
371 g_service->OnStop();
372 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
373 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest025 function end!");
374 }
375
376 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest026, TestSize.Level0)
377 {
378 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest026 function start!");
379 EXPECT_TRUE(root_);
380 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
381 g_service->OnStart();
382 std::shared_ptr<PowerStateMachine> stateMachine = g_service->GetPowerStateMachine();
383 std::shared_ptr<WakeupController> wakeupController = std::make_shared<WakeupController>(stateMachine);
384 std::string json("[]");
385 EXPECT_TRUE(wakeupController != nullptr);
386 wakeupController->WakeupParseJsonConfig(true, json);
387 g_service->OnStop();
388 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
389 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest026 function end!");
390 }
391
392 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest027, TestSize.Level0)
393 {
394 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest027 function start!");
395 EXPECT_TRUE(root_);
396 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
397 g_service->OnStart();
398 std::shared_ptr<PowerStateMachine> stateMachine = g_service->GetPowerStateMachine();
399 std::shared_ptr<WakeupController> wakeupController = std::make_shared<WakeupController>(stateMachine);
400 std::string json = R"({"touchscreen": []})";
401 EXPECT_TRUE(wakeupController != nullptr);
402 wakeupController->WakeupParseJsonConfig(true, json);
403 g_service->OnStop();
404 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
405 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest027 function end!");
406 }
407
408 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest028, TestSize.Level0)
409 {
410 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest028 function start!");
411 EXPECT_TRUE(root_);
412 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
413 g_service->OnStart();
414 std::shared_ptr<PowerStateMachine> stateMachine = g_service->GetPowerStateMachine();
415 std::shared_ptr<WakeupController> wakeupController = std::make_shared<WakeupController>(stateMachine);
416 std::string json = R"({"touchscreen": {"enable": "123"}})";
417 EXPECT_TRUE(wakeupController != nullptr);
418 wakeupController->WakeupParseJsonConfig(true, json);
419 g_service->OnStop();
420 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
421 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest028 function end!");
422 }
423
424 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest029, TestSize.Level0)
425 {
426 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest029 function start!");
427 EXPECT_TRUE(root_);
428 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
429 g_service->OnStart();
430 std::shared_ptr<PowerStateMachine> stateMachine = g_service->GetPowerStateMachine();
431 std::shared_ptr<WakeupController> wakeupController = std::make_shared<WakeupController>(stateMachine);
432 std::string json = R"({"touchscreen": {"enable": false}})";
433 EXPECT_TRUE(wakeupController != nullptr);
434 wakeupController->WakeupParseJsonConfig(true, json);
435 g_service->OnStop();
436 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
437 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest029 function end!");
438 }
439 #endif
440
441 #ifdef POWER_PICKUP_ENABLE
442 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest030, TestSize.Level0)
443 {
444 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest030 function start!");
445 EXPECT_TRUE(root_);
446 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
447 g_service->OnStart();
448 std::shared_ptr<PowerStateMachine> stateMachine = g_service->GetPowerStateMachine();
449 std::shared_ptr<WakeupController> wakeupController = std::make_shared<WakeupController>(stateMachine);
450 std::string json = R"({"pickup": {"enable": "123"}})";
451 EXPECT_TRUE(wakeupController != nullptr);
452 wakeupController->PickupWakeupParseJsonConfig(true, json);
453 g_service->OnStop();
454 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
455 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest030 function end!");
456 }
457
458 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest031, TestSize.Level0)
459 {
460 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest031 function start!");
461 EXPECT_TRUE(root_);
462 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
463 g_service->OnStart();
464 std::shared_ptr<PowerStateMachine> stateMachine = g_service->GetPowerStateMachine();
465 std::shared_ptr<WakeupController> wakeupController = std::make_shared<WakeupController>(stateMachine);
466 std::string json("");
467 EXPECT_TRUE(wakeupController != nullptr);
468 wakeupController->PickupWakeupParseJsonConfig(true, json);
469 g_service->OnStop();
470 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
471 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest031 function end!");
472 }
473
474 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest032, TestSize.Level0)
475 {
476 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest032 function start!");
477 EXPECT_TRUE(root_);
478 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
479 g_service->OnStart();
480 std::shared_ptr<PowerStateMachine> stateMachine = g_service->GetPowerStateMachine();
481 std::shared_ptr<WakeupController> wakeupController = std::make_shared<WakeupController>(stateMachine);
482 std::string json("[]");
483 EXPECT_TRUE(wakeupController != nullptr);
484 wakeupController->PickupWakeupParseJsonConfig(true, json);
485 g_service->OnStop();
486 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
487 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest032 function end!");
488 }
489
490 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest033, TestSize.Level0)
491 {
492 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest033 function start!");
493 EXPECT_TRUE(root_);
494 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
495 g_service->OnStart();
496 std::shared_ptr<PowerStateMachine> stateMachine = g_service->GetPowerStateMachine();
497 std::shared_ptr<WakeupController> wakeupController = std::make_shared<WakeupController>(stateMachine);
498 std::string json = R"({"pickup": []})";
499 EXPECT_TRUE(wakeupController != nullptr);
500 wakeupController->PickupWakeupParseJsonConfig(true, json);
501 g_service->OnStop();
502 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
503 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest033 function end!");
504 }
505
506 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest034, TestSize.Level0)
507 {
508 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest034 function start!");
509 EXPECT_TRUE(root_);
510 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
511 g_service->OnStart();
512 std::shared_ptr<PowerStateMachine> stateMachine = g_service->GetPowerStateMachine();
513 std::shared_ptr<WakeupController> wakeupController = std::make_shared<WakeupController>(stateMachine);
514 std::string json = R"({"pickup": {"enable": false}})";
515 EXPECT_TRUE(wakeupController != nullptr);
516 wakeupController->PickupWakeupParseJsonConfig(true, json);
517 g_service->OnStop();
518 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
519 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest034 function end!");
520 }
521 #endif
522
523 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest035, TestSize.Level0)
524 {
525 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest035 function start!");
526 EXPECT_TRUE(root_);
527 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
528 g_service->OnStart();
529 std::shared_ptr<PowerStateMachine> stateMachine = g_service->GetPowerStateMachine();
530 std::shared_ptr<WakeupController> wakeupController = std::make_shared<WakeupController>(stateMachine);
531 std::string json = R"({"lid": {"enable": "123"}})";
532 EXPECT_TRUE(wakeupController != nullptr);
533 wakeupController->LidWakeupParseJsonConfig(false, json);
534 g_service->OnStop();
535 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
536 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest035 function end!");
537 }
538
539 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest036, TestSize.Level0)
540 {
541 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest036 function start!");
542 EXPECT_TRUE(root_);
543 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
544 g_service->OnStart();
545 std::shared_ptr<PowerStateMachine> stateMachine = g_service->GetPowerStateMachine();
546 std::shared_ptr<WakeupController> wakeupController = std::make_shared<WakeupController>(stateMachine);
547 std::string json("");
548 EXPECT_TRUE(wakeupController != nullptr);
549 wakeupController->LidWakeupParseJsonConfig(true, json);
550 g_service->OnStop();
551 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
552 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest036 function end!");
553 }
554
555 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest037, TestSize.Level0)
556 {
557 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest037 function start!");
558 EXPECT_TRUE(root_);
559 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
560 g_service->OnStart();
561 std::shared_ptr<PowerStateMachine> stateMachine = g_service->GetPowerStateMachine();
562 std::shared_ptr<WakeupController> wakeupController = std::make_shared<WakeupController>(stateMachine);
563 std::string json("[]");
564 EXPECT_TRUE(wakeupController != nullptr);
565 wakeupController->LidWakeupParseJsonConfig(true, json);
566 g_service->OnStop();
567 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
568 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest037 function end!");
569 }
570
571 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest038, TestSize.Level0)
572 {
573 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest038 function start!");
574 EXPECT_TRUE(root_);
575 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
576 g_service->OnStart();
577 std::shared_ptr<PowerStateMachine> stateMachine = g_service->GetPowerStateMachine();
578 std::shared_ptr<WakeupController> wakeupController = std::make_shared<WakeupController>(stateMachine);
579 std::string json = R"({"lid": []})";
580 EXPECT_TRUE(wakeupController != nullptr);
581 wakeupController->LidWakeupParseJsonConfig(true, json);
582 g_service->OnStop();
583 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
584 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest038 function end!");
585 }
586
587 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest039, TestSize.Level0)
588 {
589 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest039 function start!");
590 EXPECT_TRUE(root_);
591 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
592 g_service->OnStart();
593 std::shared_ptr<PowerStateMachine> stateMachine = g_service->GetPowerStateMachine();
594 std::shared_ptr<WakeupController> wakeupController = std::make_shared<WakeupController>(stateMachine);
595 EXPECT_TRUE(wakeupController != nullptr);
596 std::string json = R"({"lid": {"enable": false}})";
597 wakeupController->LidWakeupParseJsonConfig(true, json);
598 g_service->OnStop();
599 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
600 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest039 function end!");
601 }
602
603 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest040, TestSize.Level0)
604 {
605 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest040 function start!");
606 EXPECT_TRUE(root_);
607 const std::string json = "[]";
608 auto parseSources = WakeupSourceParser::ParseSources(json);
609 std::vector<WakeupSource> sources = parseSources->GetSourceList();
610 EXPECT_EQ(sources.size(), 0);
611 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest040 function end!");
612 }
613
614 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest041, TestSize.Level0)
615 {
616 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest041 function start!");
617 EXPECT_TRUE(root_);
618 std::string key = "test";
619 std::shared_ptr<WakeupSources> parseSources = std::make_shared<WakeupSources>();
620 bool result = WakeupSourceParser::ParseSourcesProc(parseSources, nullptr, key);
621 EXPECT_FALSE(result);
622 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest041 function end!");
623 }
624
625 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest042, TestSize.Level0)
626 {
627 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest042 function start!");
628 EXPECT_TRUE(root_);
629 cJSON_AddItemToObject(root_, WakeupSource::ENABLE_KEY, cJSON_CreateBool(false));
630 cJSON_AddItemToObject(root_, WakeupSource::KEYS_KEY, cJSON_CreateNumber(NUMBER_TWO));
631
632 std::string key = "test";
633 std::shared_ptr<WakeupSources> parseSources = std::make_shared<WakeupSources>();
634 bool result = WakeupSourceParser::ParseSourcesProc(parseSources, root_, key);
635
636 EXPECT_FALSE(result);
637 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest042 function end!");
638 }
639
640 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest043, TestSize.Level0)
641 {
642 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest043 function start!");
643 EXPECT_TRUE(root_);
644 cJSON_AddItemToObject(root_, WakeupSource::ENABLE_KEY, cJSON_CreateString("not bool"));
645 cJSON_AddItemToObject(root_, WakeupSource::KEYS_KEY, cJSON_CreateString("not num"));
646
647 std::string key = "test";
648 std::shared_ptr<WakeupSources> parseSources = std::make_shared<WakeupSources>();
649 bool result = WakeupSourceParser::ParseSourcesProc(parseSources, root_, key);
650
651 EXPECT_FALSE(result);
652 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest043 function end!");
653 }
654
655 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest044, TestSize.Level0)
656 {
657 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest044 function start!");
658 EXPECT_TRUE(root_);
659 const std::string json = "";
660 VibratorSourceParser vibratorSourceParser;
661 auto parseSources = vibratorSourceParser.ParseSources(json);
662 EXPECT_EQ(parseSources.size(), 0);
663 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest044 function end!");
664 }
665
666 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest045, TestSize.Level0)
667 {
668 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest045 function start!");
669 EXPECT_TRUE(root_);
670 const std::string json = "[]";
671 VibratorSourceParser vibratorSourceParser;
672 auto parseSources = vibratorSourceParser.ParseSources(json);
673 EXPECT_EQ(parseSources.size(), 0);
674 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest045 function end!");
675 }
676
677 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest046, TestSize.Level0)
678 {
679 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest046 function start!");
680 EXPECT_TRUE(root_);
681 const std::string json = "123";
682 VibratorSourceParser vibratorSourceParser;
683 auto parseSources = vibratorSourceParser.ParseSources(json);
684 EXPECT_EQ(parseSources.size(), 0);
685 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest046 function end!");
686 }
687
688 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest047, TestSize.Level0)
689 {
690 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest047 function start!");
691 EXPECT_TRUE(root_);
692 std::string key = "test";
693 VibratorSourceParser vibratorSourceParser;
694 std::vector<VibratorSource> parseSources;
695 vibratorSourceParser.ParseSourcesProc(parseSources, nullptr, key);
696 EXPECT_TRUE(parseSources.empty());
697 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest047 function end!");
698 }
699
700 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest048, TestSize.Level0)
701 {
702 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest048 function start!");
703 EXPECT_TRUE(root_);
704 std::string key = "test";
705 VibratorSourceParser vibratorSourceParser;
706 std::vector<VibratorSource> parseSources;
707 vibratorSourceParser.ParseSourcesProc(parseSources, root_, key);
708 EXPECT_TRUE(parseSources.empty());
709 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest048 function end!");
710 }
711
712 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest049, TestSize.Level0)
713 {
714 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest049 function start!");
715 EXPECT_TRUE(root_);
716 std::string key = "test";
717 cJSON_AddItemToObject(root_, VibratorSource::ENABLE_KEY, cJSON_CreateBool(false));
718 cJSON_AddItemToObject(root_, VibratorSource::TYPE_KEY, cJSON_CreateNumber(NUMBER_TWO));
719 VibratorSourceParser vibratorSourceParser;
720 std::vector<VibratorSource> parseSources;
721 vibratorSourceParser.ParseSourcesProc(parseSources, root_, key);
722 EXPECT_TRUE(parseSources.empty());
723 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest049 function end!");
724 }
725
726 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest050, TestSize.Level0)
727 {
728 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest050 function start!");
729 EXPECT_TRUE(root_);
730 ShutdownDialog shutdownDialog;
731 std::string json = R"({"abilityName": "PowerUiExtensionAbility", "bundleName": "com.ohos.powerdialog"})";
732 shutdownDialog.ParseJsonConfig(json);
733 EXPECT_FALSE(shutdownDialog.bundleName_.empty());
734 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest050 function end!");
735 }
736
737 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest051, TestSize.Level0)
738 {
739 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest051 function start!");
740 EXPECT_TRUE(root_);
741 const std::string json = R"("this is a string")";
742 auto parseSources = SuspendSourceParser::ParseSources(json);
743 std::vector<SuspendSource> sources = parseSources->GetSourceList();
744 EXPECT_EQ(sources.size(), 0);
745 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest051 function end!");
746 }
747
748 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest052, TestSize.Level0)
749 {
750 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest052 function start!");
751 EXPECT_TRUE(root_);
752 const std::string json = R"("this is a string")";
753 VibratorSourceParser vibratorSourceParser;
754 auto parseSources = vibratorSourceParser.ParseSources(json);
755 EXPECT_EQ(parseSources.size(), 0);
756 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest052 function end!");
757 }
758
759 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest053, TestSize.Level0)
760 {
761 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest053 function start!");
762 EXPECT_TRUE(root_);
763 const std::string json = R"("this is a string")";
764 auto parseSources = WakeupSourceParser::ParseSources(json);
765 std::vector<WakeupSource> sources = parseSources->GetSourceList();
766 EXPECT_EQ(sources.size(), 0);
767 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest053 function end!");
768 }
769
770 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest054, TestSize.Level0)
771 {
772 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest054 function start!");
773 EXPECT_TRUE(root_);
774 ShutdownDialog shutdownDialog;
775 std::string json = R"({"abilityName": "PowerUiExtensionAbility", "bundleName": "com.ohos.powerdialog",
776 "uiExtensionType": "sysDialog/power"})";
777 shutdownDialog.ParseJsonConfig(json);
778 EXPECT_EQ(shutdownDialog.bundleName_, "com.ohos.powerdialog");
779 EXPECT_EQ(shutdownDialog.abilityName_, "PowerUiExtensionAbility");
780 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest054 function end!");
781 }
782
783 HWTEST_F(PowerConfigParseTest, PowerConfigParseTest055, TestSize.Level0)
784 {
785 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest055 function start!");
786 EXPECT_TRUE(root_);
787 const std::string json = R"({"lid": {"enable": false, "type": "123"}})";;
788 VibratorSourceParser vibratorSourceParser;
789 auto parseSources = vibratorSourceParser.ParseSources(json);
790 EXPECT_EQ(parseSources.size(), 0);
791 POWER_HILOGI(LABEL_TEST, "PowerConfigParseTest055 function end!");
792 }
793 } // namespace
794