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 "battery_stats_core.h" 18 #include "battery_stats_listener.h" 19 #include "battery_stats_service.h" 20 #include "stats_hisysevent.h" 21 #include "stats_log.h" 22 23 using namespace testing; 24 using namespace testing::ext; 25 using namespace OHOS::PowerMgr; 26 using namespace OHOS; 27 using namespace std; 28 class StatsServiceConfigParseTest : public Test { 29 public: SetUp()30 void SetUp() override 31 { 32 root_ = cJSON_CreateObject(); 33 } 34 TearDown()35 void TearDown() override 36 { 37 cJSON_Delete(root_); 38 } 39 40 cJSON* root_; 41 }; 42 43 namespace { 44 constexpr size_t NUMBER_UID = 100; 45 constexpr size_t NUMBER_PID = 200; 46 constexpr size_t NUMBER_TWO = 2; 47 constexpr int8_t INVALID_VALUE = -1; 48 constexpr int8_t NUMBER_0 = 0; 49 constexpr int8_t NUMBER_1 = 1; 50 constexpr int8_t NUMBER_2 = 2; 51 constexpr int8_t NUMBER_4 = 4; 52 53 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest001, TestSize.Level0) 54 { 55 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest001 function start!"); 56 ASSERT_TRUE(root_); 57 std::shared_ptr<BatteryStatsCore> statsCore = std::make_shared<BatteryStatsCore>(); 58 59 statsCore->SaveForPower(root_); 60 61 cJSON* powerObj = cJSON_GetObjectItemCaseSensitive(root_, "Power"); 62 ASSERT_TRUE(powerObj && cJSON_IsObject(powerObj)); 63 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest001 function end!"); 64 } 65 66 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest002, TestSize.Level0) 67 { 68 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest002 function start!"); 69 ASSERT_TRUE(root_); 70 std::shared_ptr<BatteryStatsCore> statsCore = std::make_shared<BatteryStatsCore>(); 71 72 statsCore->UpdateStatsEntity(root_); 73 cJSON* powerObj = cJSON_GetObjectItemCaseSensitive(root_, "Power"); 74 ASSERT_FALSE(powerObj && cJSON_IsObject(powerObj)); 75 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest002 function end!"); 76 } 77 78 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest003, TestSize.Level0) 79 { 80 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest003 function start!"); 81 ASSERT_TRUE(root_); 82 std::shared_ptr<BatteryStatsCore> statsCore = std::make_shared<BatteryStatsCore>(); 83 statsCore->SaveForPower(root_); 84 statsCore->UpdateStatsEntity(root_); 85 cJSON* powerObj = cJSON_GetObjectItemCaseSensitive(root_, "Power"); 86 ASSERT_TRUE(powerObj && cJSON_IsObject(powerObj)); 87 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest003 function end!"); 88 } 89 90 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest004, TestSize.Level0) 91 { 92 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest004 function start!"); 93 ASSERT_TRUE(root_); 94 cJSON_AddNumberToObject(root_, "UID", NUMBER_UID); 95 cJSON_AddNumberToObject(root_, "PID", NUMBER_PID); 96 cJSON_AddStringToObject(root_, "ID", "camera0"); 97 98 std::string eventName = StatsHiSysEvent::CAMERA_CONNECT; 99 StatsUtils::StatsData data; 100 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 101 listener->ProcessCameraEvent(data, root_, eventName); 102 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_CAMERA_ON); 103 EXPECT_EQ(data.state, StatsUtils::STATS_STATE_ACTIVATED); 104 EXPECT_EQ(data.uid, NUMBER_UID); 105 EXPECT_EQ(data.pid, NUMBER_PID); 106 EXPECT_EQ(data.deviceId, "camera0"); 107 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest004 function end!"); 108 } 109 110 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest005, TestSize.Level0) 111 { 112 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest005 function start!"); 113 ASSERT_TRUE(root_); 114 std::string eventName = StatsHiSysEvent::CAMERA_CONNECT; 115 StatsUtils::StatsData data; 116 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 117 listener->ProcessCameraEvent(data, root_, eventName); 118 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_CAMERA_ON); 119 EXPECT_EQ(data.state, StatsUtils::STATS_STATE_ACTIVATED); 120 EXPECT_EQ(data.uid, INVALID_VALUE); 121 EXPECT_EQ(data.pid, INVALID_VALUE); 122 EXPECT_EQ(data.deviceId, ""); 123 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest005 function end!"); 124 } 125 126 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest006, TestSize.Level0) 127 { 128 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest006 function start!"); 129 ASSERT_TRUE(root_); 130 cJSON_AddNumberToObject(root_, "ID", NUMBER_PID); 131 cJSON_AddStringToObject(root_, "UID", "camera0"); 132 cJSON_AddStringToObject(root_, "PID", "camera0"); 133 134 std::string eventName = StatsHiSysEvent::CAMERA_CONNECT; 135 StatsUtils::StatsData data; 136 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 137 listener->ProcessCameraEvent(data, root_, eventName); 138 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_CAMERA_ON); 139 EXPECT_EQ(data.state, StatsUtils::STATS_STATE_ACTIVATED); 140 EXPECT_EQ(data.uid, INVALID_VALUE); 141 EXPECT_EQ(data.pid, INVALID_VALUE); 142 EXPECT_EQ(data.deviceId, ""); 143 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest006 function end!"); 144 } 145 146 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest007, TestSize.Level0) 147 { 148 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest007 function start!"); 149 ASSERT_TRUE(root_); 150 cJSON_AddNumberToObject(root_, "UID", NUMBER_UID); 151 cJSON_AddNumberToObject(root_, "PID", NUMBER_PID); 152 cJSON_AddNumberToObject(root_, "STATE", NUMBER_TWO); 153 154 StatsUtils::StatsData data; 155 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 156 listener->ProcessAudioEvent(data, root_); 157 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_AUDIO_ON); 158 EXPECT_EQ(data.uid, NUMBER_UID); 159 EXPECT_EQ(data.pid, NUMBER_PID); 160 EXPECT_EQ(data.state, StatsUtils::STATS_STATE_ACTIVATED); 161 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest007 function end!"); 162 } 163 164 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest008, TestSize.Level0) 165 { 166 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest008 function start!"); 167 ASSERT_TRUE(root_); 168 StatsUtils::StatsData data; 169 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 170 listener->ProcessAudioEvent(data, root_); 171 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_AUDIO_ON); 172 EXPECT_EQ(data.state, INVALID_VALUE); 173 EXPECT_EQ(data.uid, INVALID_VALUE); 174 EXPECT_EQ(data.pid, INVALID_VALUE); 175 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest008 function end!"); 176 } 177 178 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest009, TestSize.Level0) 179 { 180 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest009 function start!"); 181 ASSERT_TRUE(root_); 182 cJSON_AddStringToObject(root_, "UID", "test"); 183 cJSON_AddStringToObject(root_, "PID", "test1"); 184 cJSON_AddStringToObject(root_, "STATE", "test2"); 185 186 StatsUtils::StatsData data; 187 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 188 listener->ProcessAudioEvent(data, root_); 189 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_AUDIO_ON); 190 EXPECT_EQ(data.state, INVALID_VALUE); 191 EXPECT_EQ(data.uid, INVALID_VALUE); 192 EXPECT_EQ(data.pid, INVALID_VALUE); 193 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest009 function end!"); 194 } 195 196 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest010, TestSize.Level0) 197 { 198 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest010 function start!"); 199 ASSERT_TRUE(root_); 200 cJSON_AddNumberToObject(root_, "UID", NUMBER_UID); 201 cJSON_AddNumberToObject(root_, "PID", NUMBER_PID); 202 cJSON_AddNumberToObject(root_, "STATE", 0); 203 204 std::string eventName = StatsHiSysEvent::POWER_SENSOR_GRAVITY; 205 StatsUtils::StatsData data; 206 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 207 listener->ProcessSensorEvent(data, root_, eventName); 208 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_SENSOR_GRAVITY_ON); 209 EXPECT_EQ(data.state, StatsUtils::STATS_STATE_DEACTIVATED); 210 EXPECT_EQ(data.uid, NUMBER_UID); 211 EXPECT_EQ(data.pid, NUMBER_PID); 212 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest010 function end!"); 213 } 214 215 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest011, TestSize.Level0) 216 { 217 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest011 function start!"); 218 ASSERT_TRUE(root_); 219 std::string eventName = StatsHiSysEvent::POWER_SENSOR_GRAVITY; 220 StatsUtils::StatsData data; 221 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 222 listener->ProcessSensorEvent(data, root_, eventName); 223 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_SENSOR_GRAVITY_ON); 224 EXPECT_EQ(data.state, INVALID_VALUE); 225 EXPECT_EQ(data.uid, INVALID_VALUE); 226 EXPECT_EQ(data.pid, INVALID_VALUE); 227 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest011 function end!"); 228 } 229 230 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest012, TestSize.Level0) 231 { 232 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest012 function start!"); 233 ASSERT_TRUE(root_); 234 cJSON_AddStringToObject(root_, "UID", "test"); 235 cJSON_AddStringToObject(root_, "PID", "test1"); 236 cJSON_AddStringToObject(root_, "STATE", "test2"); 237 238 std::string eventName = StatsHiSysEvent::POWER_SENSOR_GRAVITY; 239 StatsUtils::StatsData data; 240 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 241 listener->ProcessSensorEvent(data, root_, eventName); 242 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_SENSOR_GRAVITY_ON); 243 EXPECT_EQ(data.state, INVALID_VALUE); 244 EXPECT_EQ(data.uid, INVALID_VALUE); 245 EXPECT_EQ(data.pid, INVALID_VALUE); 246 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest012 function end!"); 247 } 248 249 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest013, TestSize.Level0) 250 { 251 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest013 function start!"); 252 ASSERT_TRUE(root_); 253 cJSON_AddNumberToObject(root_, "UID", NUMBER_UID); 254 cJSON_AddNumberToObject(root_, "PID", NUMBER_PID); 255 cJSON_AddStringToObject(root_, "STATE", "start"); 256 257 StatsUtils::StatsData data; 258 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 259 listener->ProcessGnssEvent(data, root_); 260 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_GNSS_ON); 261 EXPECT_EQ(data.state, StatsUtils::STATS_STATE_ACTIVATED); 262 EXPECT_EQ(data.uid, NUMBER_UID); 263 EXPECT_EQ(data.pid, NUMBER_PID); 264 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest013 function end!"); 265 } 266 267 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest014, TestSize.Level0) 268 { 269 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest014 function start!"); 270 ASSERT_TRUE(root_); 271 StatsUtils::StatsData data; 272 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 273 listener->ProcessGnssEvent(data, root_); 274 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_GNSS_ON); 275 EXPECT_EQ(data.state, INVALID_VALUE); 276 EXPECT_EQ(data.uid, INVALID_VALUE); 277 EXPECT_EQ(data.pid, INVALID_VALUE); 278 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest014 function end!"); 279 } 280 281 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest015, TestSize.Level0) 282 { 283 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest015 function start!"); 284 ASSERT_TRUE(root_); 285 cJSON_AddStringToObject(root_, "UID", "test"); 286 cJSON_AddStringToObject(root_, "PID", "test1"); 287 cJSON_AddNumberToObject(root_, "STATE", 0); 288 StatsUtils::StatsData data; 289 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 290 listener->ProcessGnssEvent(data, root_); 291 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_GNSS_ON); 292 EXPECT_EQ(data.state, INVALID_VALUE); 293 EXPECT_EQ(data.uid, INVALID_VALUE); 294 EXPECT_EQ(data.pid, INVALID_VALUE); 295 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest015 function end!"); 296 } 297 298 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest016, TestSize.Level0) 299 { 300 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest016 function start!"); 301 ASSERT_TRUE(root_); 302 cJSON_AddNumberToObject(root_, "UID", NUMBER_UID); 303 cJSON_AddNumberToObject(root_, "PID", NUMBER_PID); 304 std::string eventName = StatsHiSysEvent::DISCOVERY_STATE; 305 StatsUtils::StatsData data; 306 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 307 listener->ProcessBluetoothBrEvent(data, root_, eventName); 308 EXPECT_EQ(data.uid, NUMBER_UID); 309 EXPECT_EQ(data.pid, NUMBER_PID); 310 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest016 function end!"); 311 } 312 313 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest017, TestSize.Level0) 314 { 315 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest017 function start!"); 316 ASSERT_TRUE(root_); 317 StatsUtils::StatsData data; 318 std::string eventName = StatsHiSysEvent::DISCOVERY_STATE; 319 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 320 listener->ProcessBluetoothBrEvent(data, root_, eventName); 321 EXPECT_EQ(data.uid, INVALID_VALUE); 322 EXPECT_EQ(data.pid, INVALID_VALUE); 323 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest017 function end!"); 324 } 325 326 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest018, TestSize.Level0) 327 { 328 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest018 function start!"); 329 ASSERT_TRUE(root_); 330 cJSON_AddStringToObject(root_, "UID", "test"); 331 cJSON_AddStringToObject(root_, "PID", "test1"); 332 cJSON_AddNumberToObject(root_, "STATE", 0); 333 std::string eventName = StatsHiSysEvent::DISCOVERY_STATE; 334 StatsUtils::StatsData data; 335 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 336 listener->ProcessBluetoothBrEvent(data, root_, eventName); 337 EXPECT_EQ(data.uid, INVALID_VALUE); 338 EXPECT_EQ(data.pid, INVALID_VALUE); 339 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest018 function end!"); 340 } 341 342 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest019, TestSize.Level0) 343 { 344 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest019 function start!"); 345 ASSERT_TRUE(root_); 346 cJSON_AddNumberToObject(root_, "UID", NUMBER_UID); 347 cJSON_AddNumberToObject(root_, "PID", NUMBER_PID); 348 std::string eventName = StatsHiSysEvent::BLE_SCAN_START; 349 StatsUtils::StatsData data; 350 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 351 listener->ProcessBluetoothBleEvent(data, root_, eventName); 352 EXPECT_EQ(data.uid, NUMBER_UID); 353 EXPECT_EQ(data.pid, NUMBER_PID); 354 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest019 function end!"); 355 } 356 357 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest020, TestSize.Level0) 358 { 359 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest020 function start!"); 360 ASSERT_TRUE(root_); 361 StatsUtils::StatsData data; 362 std::string eventName = StatsHiSysEvent::BLE_SCAN_START; 363 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 364 listener->ProcessBluetoothBleEvent(data, root_, eventName); 365 EXPECT_EQ(data.uid, INVALID_VALUE); 366 EXPECT_EQ(data.pid, INVALID_VALUE); 367 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest020 function end!"); 368 } 369 370 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest021, TestSize.Level0) 371 { 372 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest021 function start!"); 373 ASSERT_TRUE(root_); 374 cJSON_AddStringToObject(root_, "UID", "test"); 375 cJSON_AddStringToObject(root_, "PID", "test1"); 376 cJSON_AddNumberToObject(root_, "STATE", 0); 377 std::string eventName = StatsHiSysEvent::BLE_SCAN_START; 378 StatsUtils::StatsData data; 379 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 380 listener->ProcessBluetoothBleEvent(data, root_, eventName); 381 EXPECT_EQ(data.uid, INVALID_VALUE); 382 EXPECT_EQ(data.pid, INVALID_VALUE); 383 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest021 function end!"); 384 } 385 386 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest022, TestSize.Level0) 387 { 388 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest022 function start!"); 389 ASSERT_TRUE(root_); 390 cJSON_AddNumberToObject(root_, "STATE", 0); 391 cJSON_AddStringToObject(root_, "name_", "name_"); 392 cJSON_AddStringToObject(root_, "SLOT_ID", "SLOT_ID"); 393 cJSON_AddStringToObject(root_, "INDEX_ID", "INDEX_ID"); 394 StatsUtils::StatsData data; 395 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 396 listener->ProcessPhoneDebugInfo(data, root_); 397 ASSERT_FALSE(data.eventDebugInfo.empty()); 398 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest022 function end!"); 399 } 400 401 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest023, TestSize.Level0) 402 { 403 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest023 function start!"); 404 ASSERT_TRUE(root_); 405 StatsUtils::StatsData data; 406 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 407 listener->ProcessPhoneDebugInfo(data, root_); 408 ASSERT_FALSE(data.eventDebugInfo.empty()); 409 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest023 function end!"); 410 } 411 412 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest024, TestSize.Level0) 413 { 414 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest024 function start!"); 415 ASSERT_TRUE(root_); 416 cJSON_AddStringToObject(root_, "STATE", "state"); 417 cJSON_AddNumberToObject(root_, "name_", 0); 418 cJSON_AddNumberToObject(root_, "SLOT_ID", 0); 419 cJSON_AddNumberToObject(root_, "INDEX_ID", 0); 420 StatsUtils::StatsData data; 421 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 422 listener->ProcessPhoneDebugInfo(data, root_); 423 ASSERT_FALSE(data.eventDebugInfo.empty()); 424 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest024 function end!"); 425 } 426 427 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest025, TestSize.Level0) 428 { 429 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest025 function start!"); 430 ASSERT_TRUE(root_); 431 std::shared_ptr<BatteryStatsCore> statsCore = std::make_shared<BatteryStatsCore>(); 432 cJSON* array = cJSON_CreateArray(); 433 cJSON_AddItemToObject(root_, "points", array); 434 statsCore->UpdateStatsEntity(array); 435 cJSON* powerObj = cJSON_GetObjectItemCaseSensitive(root_, "Power"); 436 ASSERT_FALSE(powerObj && cJSON_IsObject(powerObj)); 437 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest025 function end!"); 438 } 439 440 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest026, TestSize.Level0) 441 { 442 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest026 function start!"); 443 ASSERT_TRUE(root_); 444 std::shared_ptr<BatteryStatsCore> statsCore = std::make_shared<BatteryStatsCore>(); 445 cJSON* powerObj = cJSON_CreateObject(); 446 cJSON_AddStringToObject(powerObj, "10", "test"); 447 cJSON_AddItemToObject(root_, "Power", powerObj); 448 statsCore->UpdateStatsEntity(root_); 449 powerObj = cJSON_GetObjectItemCaseSensitive(root_, "Power"); 450 ASSERT_TRUE(powerObj && cJSON_IsObject(powerObj)); 451 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest026 function end!"); 452 } 453 454 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest027, TestSize.Level0) 455 { 456 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest027 function start!"); 457 ASSERT_TRUE(root_); 458 std::shared_ptr<BatteryStatsCore> statsCore = std::make_shared<BatteryStatsCore>(); 459 cJSON* powerObj = cJSON_CreateObject(); 460 cJSON_AddNumberToObject(powerObj, "asb", 123); 461 cJSON_AddItemToObject(root_, "Power", powerObj); 462 statsCore->UpdateStatsEntity(root_); 463 powerObj = cJSON_GetObjectItemCaseSensitive(root_, "Power"); 464 ASSERT_TRUE(powerObj && cJSON_IsObject(powerObj)); 465 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest027 function end!"); 466 } 467 468 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest028, TestSize.Level0) 469 { 470 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest028 function start!"); 471 ASSERT_TRUE(root_); 472 cJSON_AddNumberToObject(root_, "UID", NUMBER_UID); 473 cJSON_AddNumberToObject(root_, "PID", NUMBER_PID); 474 cJSON_AddStringToObject(root_, "STATE", "test"); 475 std::string eventName = StatsHiSysEvent::DISCOVERY_STATE; 476 StatsUtils::StatsData data; 477 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 478 listener->ProcessBluetoothBrEvent(data, root_, eventName); 479 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_BLUETOOTH_BR_SCAN); 480 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest028 function end!"); 481 } 482 483 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest029, TestSize.Level0) 484 { 485 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest029 function start!"); 486 ASSERT_TRUE(root_); 487 cJSON_AddNumberToObject(root_, "UID", NUMBER_UID); 488 cJSON_AddNumberToObject(root_, "PID", NUMBER_PID); 489 cJSON_AddStringToObject(root_, "STATE", "test"); 490 std::string eventName = StatsHiSysEvent::BR_SWITCH_STATE; 491 StatsUtils::StatsData data; 492 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 493 listener->ProcessBluetoothBrEvent(data, root_, eventName); 494 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_BLUETOOTH_BR_ON); 495 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest029 function end!"); 496 } 497 498 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest030, TestSize.Level0) 499 { 500 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest030 function start!"); 501 ASSERT_TRUE(root_); 502 cJSON_AddNumberToObject(root_, "UID", NUMBER_UID); 503 cJSON_AddNumberToObject(root_, "PID", NUMBER_PID); 504 cJSON_AddStringToObject(root_, "STATE", "test"); 505 std::string eventName = StatsHiSysEvent::BLE_SWITCH_STATE; 506 StatsUtils::StatsData data; 507 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 508 listener->ProcessBluetoothBleEvent(data, root_, eventName); 509 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_BLUETOOTH_BLE_ON); 510 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest030 function end!"); 511 } 512 513 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest031, TestSize.Level0) 514 { 515 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest031 function start!"); 516 ASSERT_TRUE(root_); 517 cJSON_AddStringToObject(root_, "TYPE", "test"); 518 std::string eventName = StatsHiSysEvent::WIFI_CONNECTION; 519 StatsUtils::StatsData data; 520 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 521 listener->ProcessWifiEvent(data, root_, eventName); 522 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_WIFI_ON); 523 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest031 function end!"); 524 } 525 526 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest032, TestSize.Level0) 527 { 528 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest032 function start!"); 529 ASSERT_TRUE(root_); 530 cJSON_AddStringToObject(root_, "STATE", "test"); 531 std::string eventName = StatsHiSysEvent::CALL_STATE; 532 StatsUtils::StatsData data; 533 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 534 listener->ProcessPhoneEvent(data, root_, eventName); 535 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_PHONE_ACTIVE); 536 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest032 function end!"); 537 } 538 539 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest033, TestSize.Level0) 540 { 541 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest033 function start!"); 542 ASSERT_TRUE(root_); 543 cJSON_AddStringToObject(root_, "STATE", "test"); 544 std::string eventName = StatsHiSysEvent::DATA_CONNECTION_STATE; 545 StatsUtils::StatsData data; 546 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 547 listener->ProcessPhoneEvent(data, root_, eventName); 548 EXPECT_EQ(data.type, StatsUtils::STATS_TYPE_PHONE_DATA); 549 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest033 function end!"); 550 } 551 552 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest034, TestSize.Level0) 553 { 554 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest034 function start!"); 555 ASSERT_TRUE(root_); 556 cJSON_AddStringToObject(root_, "STATE", "test"); 557 cJSON_AddStringToObject(root_, "UID", "UID"); 558 cJSON_AddStringToObject(root_, "PID", "PID"); 559 StatsUtils::StatsData data; 560 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 561 listener->ProcessFlashlightEvent(data, root_); 562 EXPECT_EQ(data.uid, INVALID_VALUE); 563 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest034 function end!"); 564 } 565 566 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest035, TestSize.Level0) 567 { 568 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest035 function start!"); 569 ASSERT_TRUE(root_); 570 cJSON_AddStringToObject(root_, "STATE", "test"); 571 cJSON_AddStringToObject(root_, "UID", "UID"); 572 cJSON_AddStringToObject(root_, "PID", "PID"); 573 StatsUtils::StatsData data; 574 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 575 listener->ProcessWakelockEvent(data, root_); 576 EXPECT_EQ(data.uid, INVALID_VALUE); 577 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest035 function end!"); 578 } 579 580 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest036, TestSize.Level0) 581 { 582 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest036 function start!"); 583 ASSERT_TRUE(root_); 584 cJSON_AddNumberToObject(root_, "STATE", NUMBER_0); 585 cJSON_AddNumberToObject(root_, "UID", NUMBER_UID); 586 cJSON_AddNumberToObject(root_, "PID", NUMBER_PID); 587 StatsUtils::StatsData data; 588 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 589 listener->ProcessWakelockEvent(data, root_); 590 EXPECT_EQ(data.uid, NUMBER_UID); 591 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest036 function end!"); 592 } 593 594 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest037, TestSize.Level0) 595 { 596 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest037 function start!"); 597 ASSERT_TRUE(root_); 598 cJSON_AddNumberToObject(root_, "STATE", NUMBER_1); 599 cJSON_AddNumberToObject(root_, "UID", NUMBER_UID); 600 cJSON_AddNumberToObject(root_, "PID", NUMBER_PID); 601 StatsUtils::StatsData data; 602 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 603 listener->ProcessWakelockEvent(data, root_); 604 EXPECT_EQ(data.uid, NUMBER_UID); 605 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest037 function end!"); 606 } 607 608 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest038, TestSize.Level0) 609 { 610 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest038 function start!"); 611 ASSERT_TRUE(root_); 612 cJSON_AddNumberToObject(root_, "STATE", NUMBER_2); 613 cJSON_AddNumberToObject(root_, "UID", NUMBER_UID); 614 cJSON_AddNumberToObject(root_, "PID", NUMBER_PID); 615 StatsUtils::StatsData data; 616 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 617 listener->ProcessWakelockEvent(data, root_); 618 EXPECT_EQ(data.uid, NUMBER_UID); 619 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest038 function end!"); 620 } 621 622 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest039, TestSize.Level0) 623 { 624 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest039 function start!"); 625 ASSERT_TRUE(root_); 626 cJSON_AddNumberToObject(root_, "STATE", NUMBER_4); 627 cJSON_AddNumberToObject(root_, "UID", NUMBER_UID); 628 cJSON_AddNumberToObject(root_, "PID", NUMBER_PID); 629 StatsUtils::StatsData data; 630 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 631 listener->ProcessWakelockEvent(data, root_); 632 EXPECT_EQ(data.uid, NUMBER_UID); 633 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest039 function end!"); 634 } 635 636 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest040, TestSize.Level0) 637 { 638 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest040 function start!"); 639 ASSERT_TRUE(root_); 640 cJSON_AddStringToObject(root_, "TYPE", "type"); 641 cJSON_AddNumberToObject(root_, "NAME", NUMBER_UID); 642 cJSON_AddNumberToObject(root_, "LOG_LEVEL", NUMBER_PID); 643 cJSON_AddNumberToObject(root_, "TAG", NUMBER_PID); 644 cJSON_AddNumberToObject(root_, "MESSAGE", NUMBER_PID); 645 StatsUtils::StatsData data; 646 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 647 listener->ProcessWakelockEventInternal(data, root_); 648 ASSERT_FALSE(data.eventDebugInfo.empty()); 649 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest040 function end!"); 650 } 651 652 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest041, TestSize.Level0) 653 { 654 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest041 function start!"); 655 ASSERT_TRUE(root_); 656 cJSON_AddNumberToObject(root_, "TYPE", NUMBER_UID); 657 cJSON_AddStringToObject(root_, "NAME", "name"); 658 cJSON_AddStringToObject(root_, "LOG_LEVEL", "log_level"); 659 cJSON_AddStringToObject(root_, "TAG", "tag"); 660 cJSON_AddStringToObject(root_, "MESSAGE", "message"); 661 StatsUtils::StatsData data; 662 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 663 listener->ProcessWakelockEventInternal(data, root_); 664 EXPECT_EQ(data.eventDataType, NUMBER_UID); 665 ASSERT_FALSE(data.eventDebugInfo.empty()); 666 EXPECT_EQ(data.eventDebugInfo, "INVALID TAG = tag MESSAGE = message"); 667 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest041 function end!"); 668 } 669 670 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest042, TestSize.Level0) 671 { 672 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest042 function start!"); 673 ASSERT_TRUE(root_); 674 cJSON_AddNumberToObject(root_, "STATE", NUMBER_UID); 675 cJSON_AddNumberToObject(root_, "BRIGHTNESS", NUMBER_UID); 676 cJSON_AddStringToObject(root_, "REASON", "reason"); 677 cJSON_AddStringToObject(root_, "name", "name"); 678 StatsUtils::StatsData data; 679 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 680 listener->ProcessDisplayDebugInfo(data, root_); 681 ASSERT_FALSE(data.eventDebugInfo.empty()); 682 EXPECT_EQ(data.eventDebugInfo, "INVALID Screen state = 100 Screen brightness = 100 Brightness reason = reason"); 683 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest042 function end!"); 684 } 685 686 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest043, TestSize.Level0) 687 { 688 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest043 function start!"); 689 ASSERT_TRUE(root_); 690 StatsUtils::StatsData data; 691 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 692 listener->ProcessDisplayDebugInfo(data, root_); 693 ASSERT_FALSE(data.eventDebugInfo.empty()); 694 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest043 function end!"); 695 } 696 697 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest044, TestSize.Level0) 698 { 699 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest044 function start!"); 700 ASSERT_TRUE(root_); 701 cJSON_AddNumberToObject(root_, "NIT", NUMBER_UID); 702 cJSON_AddNumberToObject(root_, "RATIO", NUMBER_UID); 703 cJSON_AddNumberToObject(root_, "TYPE", NUMBER_UID); 704 cJSON_AddNumberToObject(root_, "LEVEL", NUMBER_UID); 705 StatsUtils::StatsData data; 706 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 707 listener->ProcessDisplayDebugInfoInternal(data, root_); 708 ASSERT_FALSE(data.eventDebugInfo.empty()); 709 EXPECT_EQ(data.eventDebugInfo, 710 "INVALID Brightness nit = 100 Ratio = 100 Ambient type = 100 Ambient brightness = 100"); 711 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest044 function end!"); 712 } 713 714 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest045, TestSize.Level0) 715 { 716 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest045 function start!"); 717 ASSERT_TRUE(root_); 718 cJSON_AddNumberToObject(root_, "LEVEL", NUMBER_UID); 719 cJSON_AddNumberToObject(root_, "CHARGER", NUMBER_UID); 720 cJSON_AddNumberToObject(root_, "VOLTAGE", NUMBER_UID); 721 cJSON_AddNumberToObject(root_, "HEALTH", NUMBER_UID); 722 cJSON_AddNumberToObject(root_, "TEMPERATURE", NUMBER_UID); 723 StatsUtils::StatsData data; 724 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 725 listener->ProcessBatteryEvent(data, root_); 726 ASSERT_FALSE(data.eventDebugInfo.empty()); 727 EXPECT_EQ(data.level, NUMBER_UID); 728 EXPECT_EQ(data.eventDataExtra, NUMBER_UID); 729 EXPECT_EQ(data.eventDebugInfo, "INVALID Voltage = 100 Health = 100 Temperature = 100"); 730 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest045 function end!"); 731 } 732 733 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest046, TestSize.Level0) 734 { 735 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest046 function start!"); 736 ASSERT_TRUE(root_); 737 StatsUtils::StatsData data; 738 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 739 listener->ProcessBatteryEvent(data, root_); 740 ASSERT_FALSE(data.eventDebugInfo.empty()); 741 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest046 function end!"); 742 } 743 744 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest047, TestSize.Level0) 745 { 746 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest047 function start!"); 747 ASSERT_TRUE(root_); 748 StatsUtils::StatsData data; 749 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 750 listener->ProcessThermalEvent(data, root_); 751 ASSERT_FALSE(data.eventDebugInfo.empty()); 752 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest047 function end!"); 753 } 754 755 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest048, TestSize.Level0) 756 { 757 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest048 function start!"); 758 ASSERT_TRUE(root_); 759 StatsUtils::StatsData data; 760 cJSON_AddStringToObject(root_, "name_", "name"); 761 cJSON_AddStringToObject(root_, "NAME", "NAME"); 762 cJSON_AddNumberToObject(root_, "LEVEL", NUMBER_UID); 763 cJSON_AddNumberToObject(root_, "TEMPERATURE", NUMBER_UID); 764 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 765 listener->ProcessThermalEvent(data, root_); 766 ASSERT_FALSE(data.eventDebugInfo.empty()); 767 EXPECT_EQ(data.eventDebugInfo, "INVALIDEvent name = name Name = NAME Temperature = 100 Temperature level = 100"); 768 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest048 function end!"); 769 } 770 771 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest049, TestSize.Level0) 772 { 773 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest049 function start!"); 774 ASSERT_TRUE(root_); 775 StatsUtils::StatsData data; 776 cJSON_AddStringToObject(root_, "ACTION", "ACTION"); 777 cJSON_AddNumberToObject(root_, "VALUE", NUMBER_UID); 778 cJSON_AddNumberToObject(root_, "RATIO", NUMBER_UID); 779 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 780 listener->ProcessThermalEventInternal(data, root_); 781 ASSERT_FALSE(data.eventDebugInfo.empty()); 782 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest049 function end!"); 783 } 784 785 786 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest050, TestSize.Level0) 787 { 788 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest050 function start!"); 789 ASSERT_TRUE(root_); 790 StatsUtils::StatsData data; 791 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 792 listener->ProcessPowerWorkschedulerEvent(data, root_); 793 ASSERT_FALSE(data.eventDebugInfo.empty()); 794 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest050 function end!"); 795 } 796 797 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest051, TestSize.Level0) 798 { 799 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest051 function start!"); 800 ASSERT_TRUE(root_); 801 StatsUtils::StatsData data; 802 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 803 listener->ProcessOthersWorkschedulerEvent(data, root_); 804 ASSERT_FALSE(data.eventDebugInfo.empty()); 805 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest051 function end!"); 806 } 807 808 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest052, TestSize.Level0) 809 { 810 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest052 function start!"); 811 ASSERT_TRUE(root_); 812 StatsUtils::StatsData data; 813 cJSON_AddStringToObject(root_, "name_", "name"); 814 cJSON_AddStringToObject(root_, "NAME", "NAME"); 815 cJSON_AddNumberToObject(root_, "UID", NUMBER_UID); 816 cJSON_AddNumberToObject(root_, "PID", NUMBER_UID); 817 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 818 listener->ProcessOthersWorkschedulerEvent(data, root_); 819 ASSERT_FALSE(data.eventDebugInfo.empty()); 820 EXPECT_EQ(data.uid, NUMBER_UID); 821 EXPECT_EQ(data.pid, NUMBER_UID); 822 EXPECT_EQ(data.eventDebugInfo, "INVALIDname: Bundle name = NAME"); 823 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest052 function end!"); 824 } 825 826 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest053, TestSize.Level0) 827 { 828 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest053 function start!"); 829 ASSERT_TRUE(root_); 830 StatsUtils::StatsData data; 831 cJSON_AddStringToObject(root_, "WORKID", "WORKID"); 832 cJSON_AddStringToObject(root_, "TRIGGER", "TRIGGER"); 833 cJSON_AddStringToObject(root_, "TYPE", "TYPE"); 834 cJSON_AddNumberToObject(root_, "INTERVAL", NUMBER_UID); 835 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 836 listener->ProcessOthersWorkschedulerEventInternal(data, root_); 837 ASSERT_FALSE(data.eventDebugInfo.empty()); 838 EXPECT_EQ(data.eventDebugInfo, 839 "INVALID Work ID = WORKID Trigger conditions = TRIGGER Work type = TYPE Interval = 100"); 840 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest053 function end!"); 841 } 842 843 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest054, TestSize.Level0) 844 { 845 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest054 function start!"); 846 ASSERT_TRUE(root_); 847 StatsUtils::StatsData data; 848 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 849 listener->ProcessWorkschedulerEvent(data, root_); 850 ASSERT_FALSE(data.eventDebugInfo.empty()); 851 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest054 function end!"); 852 } 853 854 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest055, TestSize.Level0) 855 { 856 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest055 function start!"); 857 ASSERT_TRUE(root_); 858 StatsUtils::StatsData data; 859 cJSON_AddStringToObject(root_, "name_", "WORK_ADD"); 860 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 861 listener->ProcessWorkschedulerEvent(data, root_); 862 ASSERT_FALSE(data.eventDebugInfo.empty()); 863 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest055 function end!"); 864 } 865 866 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest056, TestSize.Level0) 867 { 868 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest056 function start!"); 869 ASSERT_TRUE(root_); 870 StatsUtils::StatsData data; 871 cJSON_AddStringToObject(root_, "name_", "WORK_ADD"); 872 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 873 listener->ProcessWorkschedulerEvent(data, root_); 874 ASSERT_FALSE(data.eventDebugInfo.empty()); 875 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest056 function end!"); 876 } 877 878 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest057, TestSize.Level0) 879 { 880 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest057 function start!"); 881 ASSERT_TRUE(root_); 882 StatsUtils::StatsData data; 883 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 884 listener->ProcessDistributedSchedulerEvent(data, root_); 885 ASSERT_FALSE(data.eventDebugInfo.empty()); 886 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest057 function end!"); 887 } 888 889 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest058, TestSize.Level0) 890 { 891 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest058 function start!"); 892 ASSERT_TRUE(root_); 893 StatsUtils::StatsData data; 894 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 895 listener->ProcessDistributedSchedulerEvent(data, root_); 896 ASSERT_FALSE(data.eventDebugInfo.empty()); 897 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest058 function end!"); 898 } 899 900 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest059, TestSize.Level0) 901 { 902 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest059 function start!"); 903 ASSERT_TRUE(root_); 904 StatsUtils::StatsData data; 905 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 906 listener->ProcessDistributedSchedulerEventInternal(data, root_); 907 ASSERT_FALSE(data.eventDebugInfo.empty()); 908 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest059 function end!"); 909 } 910 911 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest060, TestSize.Level0) 912 { 913 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest060 function start!"); 914 ASSERT_TRUE(root_); 915 StatsUtils::StatsData data; 916 std::shared_ptr<BatteryStatsListener> listener = std::make_shared<BatteryStatsListener>(); 917 listener->ProcessAlarmEvent(data, root_); 918 EXPECT_EQ(data.uid, INVALID_VALUE); 919 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest060 function end!"); 920 } 921 922 HWTEST_F(StatsServiceConfigParseTest, StatsServiceConfigParseTest061, TestSize.Level0) 923 { 924 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest061 function start!"); 925 ASSERT_TRUE(root_); 926 BatteryStatsParser batteryStatsParser; 927 cJSON* array = cJSON_CreateArray(); 928 cJSON_AddItemToObject(root_, "points", array); 929 cJSON_AddStringToObject(array, "TYPE", "TYPE"); 930 batteryStatsParser.ParsingArray("type", array); 931 ASSERT_FALSE(batteryStatsParser.averageVecMap_.empty()); 932 STATS_HILOGI(LABEL_TEST, "StatsServiceConfigParseTest061 function end!"); 933 } 934 } // namespace 935