1 /* 2 * Copyright (c) 2021 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 <fcntl.h> 17 #include <hwext/gtest-ext.h> 18 #include <hwext/gtest-tag.h> 19 #include <unordered_map> 20 21 #include "cpu_filter.h" 22 #include "htrace_cpu_detail_parser.h" 23 #include "parser/common_types.h" 24 #include "src/filter/symbols_filter.h" 25 #include "trace_streamer_filters.h" 26 #include "trace_streamer_selector.h" 27 28 using namespace testing::ext; 29 using namespace SysTuning::TraceStreamer; 30 namespace SysTuning { 31 namespace TraceStreamer { 32 const uint64_t TIMESTAMP = 1616439852302; 33 const std::string THREAD_NAME_01 = "ACCS0"; 34 const std::string THREAD_NAME_02 = "HeapTaskDaemon"; 35 const uint32_t PRIORITY_01 = 120; 36 const uint32_t PRIORITY_02 = 124; 37 const uint32_t PID_01 = 2716; 38 const uint32_t PID_02 = 2532; 39 class HtraceEventParserTest : public ::testing::Test { 40 public: SetUp()41 void SetUp() 42 { 43 stream_.InitFilter(); 44 } 45 TearDown()46 void TearDown() {} 47 48 public: 49 SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {}; 50 }; 51 52 /** 53 * @tc.name: ParseSchedSwitchEvent 54 * @tc.desc: Parse a schedswitch event in htrace format 55 * @tc.type: FUNC 56 */ 57 HWTEST_F(HtraceEventParserTest, ParseSchedSwitchEvent, TestSize.Level1) 58 { 59 TS_LOGI("test14-1"); 60 SchedSwitchFormat* event = new SchedSwitchFormat(); 61 event->set_prev_prio(PRIORITY_01); 62 event->set_next_prio(PRIORITY_02); 63 event->set_prev_pid(PID_01); 64 event->set_next_pid(PID_02); 65 event->set_prev_comm(THREAD_NAME_01); 66 event->set_next_comm(THREAD_NAME_02); 67 event->set_prev_state(1); 68 69 FtraceCpuDetailMsg ftraceCpuDetail; 70 ftraceCpuDetail.set_cpu(0); 71 ftraceCpuDetail.set_overwrite(0); 72 auto ftraceEvent = ftraceCpuDetail.add_event(); 73 74 ftraceEvent->set_timestamp(TIMESTAMP); 75 ftraceEvent->set_tgid(1); 76 ftraceEvent->set_comm(THREAD_NAME_02); 77 ftraceEvent->unsafe_arena_set_allocated_sched_switch_format(event); 78 79 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 80 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 81 eventParser.FilterAllEvents(); 82 EXPECT_TRUE(1); 83 auto realTimeStamp = stream_.traceDataCache_->GetConstSchedSliceData().TimeStamData()[0]; 84 EXPECT_TRUE(TIMESTAMP == realTimeStamp); 85 auto realCpu = stream_.traceDataCache_->GetConstSchedSliceData().CpusData()[0]; 86 EXPECT_TRUE(0 == realCpu); 87 } 88 89 /** 90 * @tc.name: ParseFtraceCpuDetailMsgHasNoEvent 91 * @tc.desc: FtraceCpuDetailMsg has no ftrace event 92 * @tc.type: FUNC 93 */ 94 HWTEST_F(HtraceEventParserTest, ParseFtraceCpuDetailMsgHasNoEvent, TestSize.Level1) 95 { 96 TS_LOGI("test14-2"); 97 FtraceCpuDetailMsg ftraceCpuDetail; 98 ftraceCpuDetail.set_cpu(0); 99 ftraceCpuDetail.set_overwrite(0); 100 101 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 102 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 103 eventParser.FilterAllEvents(); 104 105 auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_OTHER, STAT_EVENT_DATA_LOST); 106 EXPECT_TRUE(0 == eventCount); 107 } 108 109 /** 110 * @tc.name: ParseFtraceCpuDetailMsgOverwriteTrue 111 * @tc.desc: FtraceCpuDetailMsg overwrit is true 112 * @tc.type: FUNC 113 */ 114 HWTEST_F(HtraceEventParserTest, ParseFtraceCpuDetailMsgOverwriteTrue, TestSize.Level1) 115 { 116 TS_LOGI("test14-3"); 117 SchedSwitchFormat* event = new SchedSwitchFormat(); 118 event->set_prev_prio(PRIORITY_01); 119 event->set_next_prio(PRIORITY_02); 120 event->set_prev_pid(PID_01); 121 event->set_next_pid(PID_02); 122 event->set_prev_comm(THREAD_NAME_01); 123 event->set_next_comm(THREAD_NAME_02); 124 event->set_prev_state(1); 125 126 FtraceCpuDetailMsg ftraceCpuDetail; 127 ftraceCpuDetail.set_cpu(0); 128 ftraceCpuDetail.set_overwrite(1); 129 auto ftraceEvent = ftraceCpuDetail.add_event(); 130 131 ftraceEvent->set_timestamp(TIMESTAMP); 132 ftraceEvent->set_tgid(1); 133 ftraceEvent->set_comm(THREAD_NAME_02); 134 ftraceEvent->set_allocated_sched_switch_format(event); 135 136 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 137 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 138 eventParser.FilterAllEvents(); 139 auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_OTHER, STAT_EVENT_DATA_LOST); 140 EXPECT_TRUE(1 == eventCount); 141 } 142 143 /** 144 * @tc.name: ParseTaskRenameEvent 145 * @tc.desc: Parse a task_rename event in htrace format 146 * @tc.type: FUNC 147 */ 148 HWTEST_F(HtraceEventParserTest, ParseTaskRenameEvent, TestSize.Level1) 149 { 150 TS_LOGI("test14-4"); 151 TaskRenameFormat* taskRenameEvent = new TaskRenameFormat(); 152 taskRenameEvent->set_pid(PID_01); 153 taskRenameEvent->set_oldcomm(THREAD_NAME_01); 154 taskRenameEvent->set_newcomm(THREAD_NAME_02); 155 taskRenameEvent->set_oom_score_adj(1); 156 157 FtraceCpuDetailMsg ftraceCpuDetail; 158 ftraceCpuDetail.set_cpu(0); 159 ftraceCpuDetail.set_overwrite(0); 160 auto ftraceEvent = ftraceCpuDetail.add_event(); 161 162 ftraceEvent->set_timestamp(TIMESTAMP); 163 ftraceEvent->set_tgid(1); 164 ftraceEvent->set_comm(THREAD_NAME_02); 165 ftraceEvent->set_allocated_task_rename_format(taskRenameEvent); 166 167 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 168 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 169 eventParser.FilterAllEvents(); 170 auto eventCount = 171 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_TASK_RENAME, STAT_EVENT_RECEIVED); 172 EXPECT_TRUE(1 == eventCount); 173 } 174 175 /** 176 * @tc.name: ParseTaskNewtaskEvent 177 * @tc.desc: Parse a task_newtask event in htrace format 178 * @tc.type: FUNC 179 */ 180 HWTEST_F(HtraceEventParserTest, ParseTaskNewtaskEvent, TestSize.Level1) 181 { 182 TS_LOGI("test14-5"); 183 TaskNewtaskFormat* newTaskEvent = new TaskNewtaskFormat(); 184 newTaskEvent->set_pid(PID_01); 185 newTaskEvent->set_comm(THREAD_NAME_01); 186 newTaskEvent->set_clone_flags(0); 187 newTaskEvent->set_oom_score_adj(1); 188 189 FtraceCpuDetailMsg ftraceCpuDetail; 190 ftraceCpuDetail.set_cpu(0); 191 ftraceCpuDetail.set_overwrite(0); 192 auto ftraceEvent = ftraceCpuDetail.add_event(); 193 194 ftraceEvent->set_timestamp(TIMESTAMP); 195 ftraceEvent->set_tgid(1); 196 ftraceEvent->set_comm(THREAD_NAME_02); 197 ftraceEvent->set_allocated_task_newtask_format(newTaskEvent); 198 199 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 200 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 201 eventParser.FilterAllEvents(); 202 auto eventCount = 203 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_TASK_NEWTASK, STAT_EVENT_RECEIVED); 204 EXPECT_TRUE(1 == eventCount); 205 } 206 207 /** 208 * @tc.name: ParseSchedWakeupEvent 209 * @tc.desc: Parse a sched_wakeup event in htrace format 210 * @tc.type: FUNC 211 */ 212 HWTEST_F(HtraceEventParserTest, ParseSchedWakeupEvent, TestSize.Level1) 213 { 214 TS_LOGI("test14-6"); 215 SchedWakeupFormat* wakeupEvent = new SchedWakeupFormat(); 216 wakeupEvent->set_comm(THREAD_NAME_01); 217 wakeupEvent->set_pid(PRIORITY_02); 218 wakeupEvent->set_prio(PID_01); 219 wakeupEvent->set_target_cpu(1); 220 221 FtraceCpuDetailMsg ftraceCpuDetail; 222 ftraceCpuDetail.set_cpu(0); 223 ftraceCpuDetail.set_overwrite(0); 224 auto ftraceEvent = ftraceCpuDetail.add_event(); 225 226 ftraceEvent->set_timestamp(TIMESTAMP); 227 ftraceEvent->set_tgid(1); 228 ftraceEvent->set_comm(THREAD_NAME_02); 229 ftraceEvent->set_allocated_sched_wakeup_format(wakeupEvent); 230 231 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 232 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 233 eventParser.FilterAllEvents(); 234 auto eventCount = 235 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_SCHED_WAKEUP, STAT_EVENT_RECEIVED); 236 EXPECT_TRUE(1 == eventCount); 237 } 238 239 /** 240 * @tc.name: ParseSchedWakingEvent 241 * @tc.desc: Parse a sched_waking event in htrace format 242 * @tc.type: FUNC 243 */ 244 HWTEST_F(HtraceEventParserTest, ParseSchedWakingEvent, TestSize.Level1) 245 { 246 TS_LOGI("test14-7"); 247 SchedWakingFormat* wakingEvent = new SchedWakingFormat(); 248 wakingEvent->set_comm(THREAD_NAME_01); 249 wakingEvent->set_pid(PRIORITY_02); 250 wakingEvent->set_prio(PID_01); 251 wakingEvent->set_target_cpu(1); 252 253 FtraceCpuDetailMsg ftraceCpuDetail; 254 ftraceCpuDetail.set_cpu(0); 255 ftraceCpuDetail.set_overwrite(0); 256 auto ftraceEvent = ftraceCpuDetail.add_event(); 257 258 ftraceEvent->set_timestamp(TIMESTAMP); 259 ftraceEvent->set_tgid(1); 260 ftraceEvent->set_comm(THREAD_NAME_02); 261 ftraceEvent->set_allocated_sched_waking_format(wakingEvent); 262 263 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 264 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 265 eventParser.FilterAllEvents(); 266 auto eventCount = 267 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_SCHED_WAKING, STAT_EVENT_RECEIVED); 268 EXPECT_TRUE(1 == eventCount); 269 } 270 271 /** 272 * @tc.name: ParseCpuIdleEvent 273 * @tc.desc: Parse a cpuIdle event in htrace format 274 * @tc.type: FUNC 275 */ 276 HWTEST_F(HtraceEventParserTest, ParseCpuIdleEvent, TestSize.Level1) 277 { 278 TS_LOGI("test14-8"); 279 CpuIdleFormat* cpuIdleEvent = new CpuIdleFormat(); 280 cpuIdleEvent->set_cpu_id(0); 281 cpuIdleEvent->set_state(1); 282 283 FtraceCpuDetailMsg ftraceCpuDetail; 284 ftraceCpuDetail.set_cpu(0); 285 ftraceCpuDetail.set_overwrite(0); 286 auto ftraceEvent = ftraceCpuDetail.add_event(); 287 288 ftraceEvent->set_timestamp(TIMESTAMP); 289 ftraceEvent->set_tgid(1); 290 ftraceEvent->set_comm(THREAD_NAME_02); 291 ftraceEvent->set_allocated_cpu_idle_format(cpuIdleEvent); 292 293 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 294 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 295 eventParser.FilterAllEvents(); 296 auto eventCount = 297 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CPU_IDLE, STAT_EVENT_RECEIVED); 298 EXPECT_TRUE(1 == eventCount); 299 } 300 301 /** 302 * @tc.name: ParseCpuFrequencyEvent 303 * @tc.desc: Parse a CpuFrequency event in htrace format 304 * @tc.type: FUNC 305 */ 306 HWTEST_F(HtraceEventParserTest, ParseCpuFrequencyEvent, TestSize.Level1) 307 { 308 TS_LOGI("test14-9"); 309 CpuFrequencyFormat* cpuFrequencyEvent = new CpuFrequencyFormat(); 310 cpuFrequencyEvent->set_cpu_id(0); 311 cpuFrequencyEvent->set_state(1); 312 313 FtraceCpuDetailMsg ftraceCpuDetail; 314 ftraceCpuDetail.set_cpu(0); 315 ftraceCpuDetail.set_overwrite(0); 316 auto ftraceEvent = ftraceCpuDetail.add_event(); 317 318 ftraceEvent->set_timestamp(TIMESTAMP); 319 ftraceEvent->set_tgid(2); 320 ftraceEvent->set_comm(THREAD_NAME_02); 321 ftraceEvent->set_allocated_cpu_frequency_format(cpuFrequencyEvent); 322 323 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 324 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 325 eventParser.FilterAllEvents(); 326 auto eventCount = 327 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_RECEIVED); 328 EXPECT_TRUE(1 == eventCount); 329 } 330 331 /** 332 * @tc.name: ParseWorkqueueExecuteStartEvent 333 * @tc.desc: Parse a WorkqueueExecuteStart event in htrace format 334 * @tc.type: FUNC 335 */ 336 HWTEST_F(HtraceEventParserTest, ParseWorkqueueExecuteStartEvent, TestSize.Level1) 337 { 338 TS_LOGI("test14-10"); 339 stream_.streamFilters_->symbolsFilter_->RegisterFunc(1, 1); 340 auto funcNum = stream_.streamFilters_->symbolsFilter_->GetFunc(1); 341 WorkqueueExecuteStartFormat* workqueueExecuteStartEvent = new WorkqueueExecuteStartFormat(); 342 workqueueExecuteStartEvent->set_work(0); 343 workqueueExecuteStartEvent->set_function(1); 344 345 FtraceCpuDetailMsg ftraceCpuDetail; 346 ftraceCpuDetail.set_cpu(0); 347 ftraceCpuDetail.set_overwrite(0); 348 auto ftraceEvent = ftraceCpuDetail.add_event(); 349 350 ftraceEvent->set_timestamp(TIMESTAMP); 351 ftraceEvent->set_tgid(1); 352 ftraceEvent->set_comm(THREAD_NAME_02); 353 ftraceEvent->set_allocated_workqueue_execute_start_format(workqueueExecuteStartEvent); 354 355 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 356 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 357 eventParser.FilterAllEvents(); 358 auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_WORKQUEUE_EXECUTE_START, 359 STAT_EVENT_RECEIVED); 360 EXPECT_TRUE(1 == eventCount); 361 } 362 363 /** 364 * @tc.name: ParseWorkqueueExecuteEndEvent 365 * @tc.desc: Parse a WorkqueueExecuteEnd event in htrace format 366 * @tc.type: FUNC 367 */ 368 HWTEST_F(HtraceEventParserTest, ParseWorkqueueExecuteEndEvent, TestSize.Level1) 369 { 370 TS_LOGI("test14-11"); 371 WorkqueueExecuteEndFormat* workqueueExecuteEndEvent = new WorkqueueExecuteEndFormat(); 372 workqueueExecuteEndEvent->set_work(0); 373 374 FtraceCpuDetailMsg ftraceCpuDetail; 375 ftraceCpuDetail.set_cpu(0); 376 ftraceCpuDetail.set_overwrite(0); 377 auto ftraceEvent = ftraceCpuDetail.add_event(); 378 379 ftraceEvent->set_timestamp(TIMESTAMP); 380 ftraceEvent->set_tgid(1); 381 ftraceEvent->set_comm(THREAD_NAME_02); 382 ftraceEvent->set_allocated_workqueue_execute_end_format(workqueueExecuteEndEvent); 383 384 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 385 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 386 eventParser.FilterAllEvents(); 387 auto eventCount = 388 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_WORKQUEUE_EXECUTE_END, STAT_EVENT_RECEIVED); 389 EXPECT_TRUE(1 == eventCount); 390 } 391 392 /** 393 * @tc.name: ParseClockDisableEvent 394 * @tc.desc: Parse a clock_Disable event in htrace format 395 * @tc.type: FUNC 396 */ 397 HWTEST_F(HtraceEventParserTest, ParseClockDisableEvent, TestSize.Level1) 398 { 399 TS_LOGI("test14-12"); 400 ClockDisableFormat* clockDisableEvent = new ClockDisableFormat(); 401 clockDisableEvent->set_name(THREAD_NAME_02); 402 clockDisableEvent->set_cpu_id(0); 403 clockDisableEvent->set_state(1); 404 405 FtraceCpuDetailMsg ftraceCpuDetail; 406 ftraceCpuDetail.set_cpu(0); 407 ftraceCpuDetail.set_overwrite(0); 408 auto ftraceEvent = ftraceCpuDetail.add_event(); 409 410 ftraceEvent->set_timestamp(TIMESTAMP); 411 ftraceEvent->set_tgid(2); 412 ftraceEvent->set_comm(THREAD_NAME_02); 413 ftraceEvent->set_allocated_clock_disable_format(clockDisableEvent); 414 415 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 416 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 417 eventParser.FilterAllEvents(); 418 auto eventCount = 419 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLOCK_DISABLE, STAT_EVENT_RECEIVED); 420 EXPECT_TRUE(1 == eventCount); 421 } 422 423 /** 424 * @tc.name: ParseClockEnableEvent 425 * @tc.desc: Parse a clock_Enable event in htrace format 426 * @tc.type: FUNC 427 */ 428 HWTEST_F(HtraceEventParserTest, ParseClockEnableEvent, TestSize.Level1) 429 { 430 TS_LOGI("test14-13"); 431 ClockEnableFormat* clockEnableEvent = new ClockEnableFormat(); 432 clockEnableEvent->set_name(THREAD_NAME_02); 433 clockEnableEvent->set_cpu_id(0); 434 clockEnableEvent->set_state(1); 435 436 FtraceCpuDetailMsg ftraceCpuDetail; 437 ftraceCpuDetail.set_cpu(0); 438 ftraceCpuDetail.set_overwrite(0); 439 auto ftraceEvent = ftraceCpuDetail.add_event(); 440 441 ftraceEvent->set_timestamp(TIMESTAMP); 442 ftraceEvent->set_tgid(2); 443 ftraceEvent->set_comm(THREAD_NAME_02); 444 ftraceEvent->set_allocated_clock_enable_format(clockEnableEvent); 445 446 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 447 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 448 eventParser.FilterAllEvents(); 449 auto eventCount = 450 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLOCK_ENABLE, STAT_EVENT_RECEIVED); 451 EXPECT_TRUE(1 == eventCount); 452 } 453 454 /** 455 * @tc.name: ParseClockSetRateEvent 456 * @tc.desc: Parse a clock_set_rate event in htrace format 457 * @tc.type: FUNC 458 */ 459 HWTEST_F(HtraceEventParserTest, ParseClockSetRateEvent, TestSize.Level1) 460 { 461 TS_LOGI("test14-14"); 462 ClockSetRateFormat* clockSetRateEvent = new ClockSetRateFormat(); 463 clockSetRateEvent->set_name(THREAD_NAME_02); 464 clockSetRateEvent->set_cpu_id(0); 465 clockSetRateEvent->set_state(1); 466 467 FtraceCpuDetailMsg ftraceCpuDetail; 468 ftraceCpuDetail.set_cpu(0); 469 ftraceCpuDetail.set_overwrite(0); 470 auto ftraceEvent = ftraceCpuDetail.add_event(); 471 472 ftraceEvent->set_timestamp(TIMESTAMP); 473 ftraceEvent->set_tgid(2); 474 ftraceEvent->set_comm(THREAD_NAME_02); 475 ftraceEvent->set_allocated_clock_set_rate_format(clockSetRateEvent); 476 477 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 478 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 479 eventParser.FilterAllEvents(); 480 auto eventCount = 481 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLOCK_SET_RATE, STAT_EVENT_RECEIVED); 482 EXPECT_TRUE(1 == eventCount); 483 } 484 485 /** 486 * @tc.name: ParseClkDisableEvent 487 * @tc.desc: Parse a clk_Disable event in htrace format 488 * @tc.type: FUNC 489 */ 490 HWTEST_F(HtraceEventParserTest, ParseClkDisableEvent, TestSize.Level1) 491 { 492 TS_LOGI("test14-15"); 493 ClkDisableFormat* clkDisableEvent = new ClkDisableFormat(); 494 clkDisableEvent->set_name(THREAD_NAME_02); 495 496 FtraceCpuDetailMsg ftraceCpuDetail; 497 ftraceCpuDetail.set_cpu(0); 498 ftraceCpuDetail.set_overwrite(0); 499 auto ftraceEvent = ftraceCpuDetail.add_event(); 500 501 ftraceEvent->set_timestamp(TIMESTAMP); 502 ftraceEvent->set_tgid(2); 503 ftraceEvent->set_comm(THREAD_NAME_02); 504 ftraceEvent->set_allocated_clk_disable_format(clkDisableEvent); 505 506 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 507 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 508 eventParser.FilterAllEvents(); 509 auto eventCount = 510 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLK_DISABLE, STAT_EVENT_RECEIVED); 511 EXPECT_TRUE(1 == eventCount); 512 } 513 514 /** 515 * @tc.name: ParseClkEnableEvent 516 * @tc.desc: Parse a clk_Enable event in htrace format 517 * @tc.type: FUNC 518 */ 519 HWTEST_F(HtraceEventParserTest, ParseClkEnableEvent, TestSize.Level1) 520 { 521 TS_LOGI("test14-16"); 522 ClkEnableFormat* clkEnableEvent = new ClkEnableFormat(); 523 clkEnableEvent->set_name(THREAD_NAME_02); 524 525 FtraceCpuDetailMsg ftraceCpuDetail; 526 ftraceCpuDetail.set_cpu(0); 527 ftraceCpuDetail.set_overwrite(0); 528 auto ftraceEvent = ftraceCpuDetail.add_event(); 529 530 ftraceEvent->set_timestamp(TIMESTAMP); 531 ftraceEvent->set_tgid(2); 532 ftraceEvent->set_comm(THREAD_NAME_02); 533 ftraceEvent->set_allocated_clk_enable_format(clkEnableEvent); 534 535 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 536 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 537 eventParser.FilterAllEvents(); 538 auto eventCount = 539 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLK_ENABLE, STAT_EVENT_RECEIVED); 540 EXPECT_TRUE(1 == eventCount); 541 } 542 543 /** 544 * @tc.name: ParseClkSetRateEvent 545 * @tc.desc: Parse a clk_set_rate event in htrace format 546 * @tc.type: FUNC 547 */ 548 HWTEST_F(HtraceEventParserTest, ParseClkSetRateEvent, TestSize.Level1) 549 { 550 TS_LOGI("test14-17"); 551 ClkSetRateFormat* clkSetRateEvent = new ClkSetRateFormat(); 552 clkSetRateEvent->set_name(THREAD_NAME_02); 553 clkSetRateEvent->set_rate(1); 554 555 FtraceCpuDetailMsg ftraceCpuDetail; 556 ftraceCpuDetail.set_cpu(0); 557 ftraceCpuDetail.set_overwrite(0); 558 auto ftraceEvent = ftraceCpuDetail.add_event(); 559 560 ftraceEvent->set_timestamp(TIMESTAMP); 561 ftraceEvent->set_tgid(2); 562 ftraceEvent->set_comm(THREAD_NAME_02); 563 ftraceEvent->set_allocated_clk_set_rate_format(clkSetRateEvent); 564 565 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 566 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 567 eventParser.FilterAllEvents(); 568 auto eventCount = 569 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLK_SET_RATE, STAT_EVENT_RECEIVED); 570 EXPECT_TRUE(1 == eventCount); 571 } 572 573 /** 574 * @tc.name: ParseSysEnterEvent 575 * @tc.desc: Parse a sysEnter event in htrace format 576 * @tc.type: FUNC 577 */ 578 HWTEST_F(HtraceEventParserTest, ParseSysEnterEvent, TestSize.Level1) 579 { 580 TS_LOGI("test14-18"); 581 SysEnterFormat* sysEnterEvent = new SysEnterFormat(); 582 sysEnterEvent->set_id(1); 583 sysEnterEvent->set_args(THREAD_NAME_02); 584 585 FtraceCpuDetailMsg ftraceCpuDetail; 586 ftraceCpuDetail.set_cpu(0); 587 ftraceCpuDetail.set_overwrite(0); 588 auto ftraceEvent = ftraceCpuDetail.add_event(); 589 590 ftraceEvent->set_timestamp(TIMESTAMP); 591 ftraceEvent->set_tgid(2); 592 ftraceEvent->set_comm(THREAD_NAME_02); 593 ftraceEvent->set_allocated_sys_enter_format(sysEnterEvent); 594 595 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 596 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 597 eventParser.FilterAllEvents(); 598 auto eventCount = 599 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_SYS_ENTRY, STAT_EVENT_RECEIVED); 600 EXPECT_TRUE(1 == eventCount); 601 } 602 /** 603 * @tc.name: ParseSystemExitEvent 604 * @tc.desc: Parse a system_exit event in htrace format 605 * @tc.type: FUNC 606 */ 607 HWTEST_F(HtraceEventParserTest, ParseSystemExitEvent, TestSize.Level1) 608 { 609 TS_LOGI("test14-19"); 610 SysExitFormat* sysExitEvent = new SysExitFormat(); 611 sysExitEvent->set_id(1); 612 sysExitEvent->set_ret(1); 613 614 FtraceCpuDetailMsg ftraceCpuDetail; 615 ftraceCpuDetail.set_cpu(0); 616 ftraceCpuDetail.set_overwrite(0); 617 auto ftraceEvent = ftraceCpuDetail.add_event(); 618 619 ftraceEvent->set_timestamp(TIMESTAMP); 620 ftraceEvent->set_tgid(2); 621 ftraceEvent->set_comm(THREAD_NAME_02); 622 ftraceEvent->set_allocated_sys_exit_format(sysExitEvent); 623 624 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 625 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 626 eventParser.FilterAllEvents(); 627 auto eventCount = 628 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_SYS_EXIT, STAT_EVENT_RECEIVED); 629 EXPECT_TRUE(1 == eventCount); 630 } 631 } // namespace TraceStreamer 632 } // namespace SysTuning 633