1 /* 2 * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved. 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 <hwext/gtest-ext.h> 17 #include <hwext/gtest-tag.h> 18 19 #include "cpu_detail_parser.h" 20 #include "ftrace_event_processor.h" 21 #include "trace_streamer_selector.h" 22 23 using namespace testing::ext; 24 using namespace SysTuning::TraceStreamer; 25 26 namespace SysTuning { 27 namespace TraceStreamer { 28 class RawtraceCpuDetailParserTest : public ::testing::Test { 29 public: SetUp()30 void SetUp() 31 { 32 selector_.InitFilter(); 33 selector_.EnableMetaTable(false); 34 cpuDetailParser_ = 35 std::make_unique<CpuDetailParser>(selector_.traceDataCache_.get(), selector_.streamFilters_.get()); 36 ftraceEvent_ = std::make_unique<FtraceEvent>(); 37 } 38 TearDown() const39 void TearDown() const {} 40 41 public: 42 SysTuning::TraceStreamer::TraceStreamerSelector selector_ = {}; 43 std::unique_ptr<CpuDetailParser> cpuDetailParser_ = {}; 44 std::unique_ptr<FtraceEvent> ftraceEvent_ = {}; 45 std::vector<uint8_t> data_; 46 EventFormat format_; 47 RawTraceEventInfo eventInfo_; 48 }; 49 50 /** 51 * @tc.name: ParseSchedSwitchEvent 52 * @tc.desc: Test CpuDetailParser: Parse SchedSwitchEvent 53 * @tc.type: FUNC 54 */ 55 HWTEST_F(RawtraceCpuDetailParserTest, ParseSchedSwitchEvent, TestSize.Level1) 56 { 57 TS_LOGI("test39-1"); 58 EXPECT_TRUE(FtraceEventProcessor::GetInstance().SchedSwitch(*ftraceEvent_, data_.data(), data_.size(), format_)); 59 eventInfo_.msgPtr = std::move(ftraceEvent_); 60 EXPECT_TRUE(cpuDetailParser_->SchedSwitchEvent(eventInfo_)); 61 } 62 /** 63 * @tc.name: ParseSchedBlockReasonEvent 64 * @tc.desc: Test CpuDetailParser: Parse SchedBlockReasonEvent 65 * @tc.type: FUNC 66 */ 67 HWTEST_F(RawtraceCpuDetailParserTest, ParseSchedBlockReasonEvent, TestSize.Level1) 68 { 69 TS_LOGI("test39-2"); 70 EXPECT_TRUE( 71 FtraceEventProcessor::GetInstance().SchedBlockedReason(*ftraceEvent_, data_.data(), data_.size(), format_)); 72 eventInfo_.msgPtr = std::move(ftraceEvent_); 73 EXPECT_TRUE(cpuDetailParser_->SchedBlockReasonEvent(eventInfo_)); 74 } 75 /** 76 * @tc.name: ParseSchedWakeupEvent 77 * @tc.desc: Test CpuDetailParser: Parse SchedWakeupEvent 78 * @tc.type: FUNC 79 */ 80 HWTEST_F(RawtraceCpuDetailParserTest, ParseSchedWakeupEvent, TestSize.Level1) 81 { 82 TS_LOGI("test39-3"); 83 EXPECT_TRUE(FtraceEventProcessor::GetInstance().SchedWakeup(*ftraceEvent_, data_.data(), data_.size(), format_)); 84 eventInfo_.msgPtr = std::move(ftraceEvent_); 85 EXPECT_TRUE(cpuDetailParser_->SchedWakeupEvent(eventInfo_)); 86 } 87 /** 88 * @tc.name: ParseSchedWakingEvent 89 * @tc.desc: Test CpuDetailParser: Parse SchedWakingEvent 90 * @tc.type: FUNC 91 */ 92 HWTEST_F(RawtraceCpuDetailParserTest, ParseSchedWakingEvent, TestSize.Level1) 93 { 94 TS_LOGI("test39-4"); 95 EXPECT_TRUE(FtraceEventProcessor::GetInstance().SchedWaking(*ftraceEvent_, data_.data(), data_.size(), format_)); 96 eventInfo_.msgPtr = std::move(ftraceEvent_); 97 EXPECT_TRUE(cpuDetailParser_->SchedWakingEvent(eventInfo_)); 98 } 99 /** 100 * @tc.name: ParseSchedWakeupNewEvent 101 * @tc.desc: Test CpuDetailParser: Parse SchedWakeupNewEvent 102 * @tc.type: FUNC 103 */ 104 HWTEST_F(RawtraceCpuDetailParserTest, ParseSchedWakeupNewEvent, TestSize.Level1) 105 { 106 TS_LOGI("test39-5"); 107 EXPECT_TRUE(FtraceEventProcessor::GetInstance().SchedWakeupNew(*ftraceEvent_, data_.data(), data_.size(), format_)); 108 eventInfo_.msgPtr = std::move(ftraceEvent_); 109 EXPECT_TRUE(cpuDetailParser_->SchedWakeupNewEvent(eventInfo_)); 110 } 111 /** 112 * @tc.name: ParseProcessExitEvent 113 * @tc.desc: Test CpuDetailParser: Parse ProcessExitEvent 114 * @tc.type: FUNC 115 */ 116 HWTEST_F(RawtraceCpuDetailParserTest, ParseProcessExitEvent, TestSize.Level1) 117 { 118 TS_LOGI("test39-6"); 119 EXPECT_TRUE( 120 FtraceEventProcessor::GetInstance().SchedProcessExit(*ftraceEvent_, data_.data(), data_.size(), format_)); 121 eventInfo_.msgPtr = std::move(ftraceEvent_); 122 EXPECT_TRUE(cpuDetailParser_->ProcessExitEvent(eventInfo_)); 123 } 124 /** 125 * @tc.name: ParseProcessFreeEvent 126 * @tc.desc: Test CpuDetailParser: Parse ProcessFreeEvent 127 * @tc.type: FUNC 128 */ 129 HWTEST_F(RawtraceCpuDetailParserTest, ParseProcessFreeEvent, TestSize.Level1) 130 { 131 TS_LOGI("test39-7"); 132 EXPECT_TRUE( 133 FtraceEventProcessor::GetInstance().SchedProcessFree(*ftraceEvent_, data_.data(), data_.size(), format_)); 134 eventInfo_.msgPtr = std::move(ftraceEvent_); 135 EXPECT_TRUE(cpuDetailParser_->ProcessFreeEvent(eventInfo_)); 136 } 137 /** 138 * @tc.name: ParseBinderTractionEvent 139 * @tc.desc: Test CpuDetailParser: Parse BinderTractionEvent 140 * @tc.type: FUNC 141 */ 142 HWTEST_F(RawtraceCpuDetailParserTest, ParseBinderTractionEvent, TestSize.Level1) 143 { 144 TS_LOGI("test39-8"); 145 EXPECT_TRUE( 146 FtraceEventProcessor::GetInstance().BinderTransaction(*ftraceEvent_, data_.data(), data_.size(), format_)); 147 eventInfo_.msgPtr = std::move(ftraceEvent_); 148 EXPECT_TRUE(cpuDetailParser_->BinderTractionEvent(eventInfo_)); 149 } 150 /** 151 * @tc.name: ParseBinderTractionReceivedEvent 152 * @tc.desc: Test CpuDetailParser: Parse BinderTractionReceivedEvent 153 * @tc.type: FUNC 154 */ 155 HWTEST_F(RawtraceCpuDetailParserTest, ParseBinderTractionReceivedEvent, TestSize.Level1) 156 { 157 TS_LOGI("test39-9"); 158 EXPECT_TRUE(FtraceEventProcessor::GetInstance().BinderTransactionReceived(*ftraceEvent_, data_.data(), data_.size(), 159 format_)); 160 eventInfo_.msgPtr = std::move(ftraceEvent_); 161 EXPECT_TRUE(cpuDetailParser_->BinderTractionReceivedEvent(eventInfo_)); 162 } 163 /** 164 * @tc.name: ParseBinderTractionAllocBufEvent 165 * @tc.desc: Test CpuDetailParser: Parse BinderTractionAllocBufEvent 166 * @tc.type: FUNC 167 */ 168 HWTEST_F(RawtraceCpuDetailParserTest, ParseBinderTractionAllocBufEvent, TestSize.Level1) 169 { 170 TS_LOGI("test39-10"); 171 EXPECT_TRUE(FtraceEventProcessor::GetInstance().BinderTransactionAllocBuf(*ftraceEvent_, data_.data(), data_.size(), 172 format_)); 173 eventInfo_.msgPtr = std::move(ftraceEvent_); 174 EXPECT_TRUE(cpuDetailParser_->BinderTractionAllocBufEvent(eventInfo_)); 175 } 176 /** 177 * @tc.name: ParseBinderTractionLockEvent 178 * @tc.desc: Test CpuDetailParser: Parse BinderTractionLockEvent 179 * @tc.type: FUNC 180 */ 181 HWTEST_F(RawtraceCpuDetailParserTest, ParseBinderTractionLockEvent, TestSize.Level1) 182 { 183 TS_LOGI("test39-11"); 184 EXPECT_TRUE(FtraceEventProcessor::GetInstance().BinderTransactionAllocLock(*ftraceEvent_, data_.data(), 185 data_.size(), format_)); 186 eventInfo_.msgPtr = std::move(ftraceEvent_); 187 EXPECT_TRUE(cpuDetailParser_->BinderTractionLockEvent(eventInfo_)); 188 } 189 /** 190 * @tc.name: ParseBinderTractionLockedEvent 191 * @tc.desc: Test CpuDetailParser: Parse BinderTractionLockedEvent 192 * @tc.type: FUNC 193 */ 194 HWTEST_F(RawtraceCpuDetailParserTest, ParseBinderTractionLockedEvent, TestSize.Level1) 195 { 196 TS_LOGI("test39-12"); 197 EXPECT_TRUE(FtraceEventProcessor::GetInstance().BinderTransactionAllocLocked(*ftraceEvent_, data_.data(), 198 data_.size(), format_)); 199 eventInfo_.msgPtr = std::move(ftraceEvent_); 200 EXPECT_TRUE(cpuDetailParser_->BinderTractionLockedEvent(eventInfo_)); 201 } 202 /** 203 * @tc.name: ParseBinderTractionUnLockEvent 204 * @tc.desc: Test CpuDetailParser: Parse BinderTractionUnLockEvent 205 * @tc.type: FUNC 206 */ 207 HWTEST_F(RawtraceCpuDetailParserTest, ParseBinderTractionUnLockEvent, TestSize.Level1) 208 { 209 TS_LOGI("test39-13"); 210 EXPECT_TRUE(FtraceEventProcessor::GetInstance().BinderTransactionAllocUnlock(*ftraceEvent_, data_.data(), 211 data_.size(), format_)); 212 eventInfo_.msgPtr = std::move(ftraceEvent_); 213 EXPECT_TRUE(cpuDetailParser_->BinderTractionUnLockEvent(eventInfo_)); 214 } 215 /** 216 * @tc.name: ParseTaskRenameEvent 217 * @tc.desc: Test CpuDetailParser: Parse TaskRenameEvent 218 * @tc.type: FUNC 219 */ 220 HWTEST_F(RawtraceCpuDetailParserTest, ParseTaskRenameEvent, TestSize.Level1) 221 { 222 TS_LOGI("test39-14"); 223 EXPECT_TRUE(FtraceEventProcessor::GetInstance().TaskRename(*ftraceEvent_, data_.data(), data_.size(), format_)); 224 eventInfo_.msgPtr = std::move(ftraceEvent_); 225 EXPECT_TRUE(cpuDetailParser_->TaskRenameEvent(eventInfo_)); 226 } 227 /** 228 * @tc.name: ParseTaskNewtaskEvent 229 * @tc.desc: Test CpuDetailParser: Parse TaskNewtaskEvent 230 * @tc.type: FUNC 231 */ 232 HWTEST_F(RawtraceCpuDetailParserTest, ParseTaskNewtaskEvent, TestSize.Level1) 233 { 234 TS_LOGI("test39-15"); 235 EXPECT_TRUE(FtraceEventProcessor::GetInstance().TaskNewtask(*ftraceEvent_, data_.data(), data_.size(), format_)); 236 eventInfo_.msgPtr = std::move(ftraceEvent_); 237 EXPECT_TRUE(cpuDetailParser_->TaskNewtaskEvent(eventInfo_)); 238 } 239 /** 240 * @tc.name: ParseTracingMarkWriteOrPrintEvent 241 * @tc.desc: Test CpuDetailParser: Parse TracingMarkWriteOrPrintEvent 242 * @tc.type: FUNC 243 */ 244 HWTEST_F(RawtraceCpuDetailParserTest, ParseTracingMarkWriteOrPrintEvent, TestSize.Level1) 245 { 246 TS_LOGI("test39-16"); 247 EXPECT_TRUE(FtraceEventProcessor::GetInstance().TracingMarkWriteOrPrintFormat(*ftraceEvent_, data_.data(), 248 data_.size(), format_)); 249 eventInfo_.msgPtr = std::move(ftraceEvent_); 250 EXPECT_TRUE(cpuDetailParser_->ParseTracingMarkWriteOrPrintEvent(eventInfo_)); 251 } 252 /** 253 * @tc.name: ParseCpuIdleEvent 254 * @tc.desc: Test CpuDetailParser: Parse CpuIdleEvent 255 * @tc.type: FUNC 256 */ 257 HWTEST_F(RawtraceCpuDetailParserTest, ParseCpuIdleEvent, TestSize.Level1) 258 { 259 TS_LOGI("test39-17"); 260 EXPECT_TRUE(FtraceEventProcessor::GetInstance().CpuIdle(*ftraceEvent_, data_.data(), data_.size(), format_)); 261 eventInfo_.msgPtr = std::move(ftraceEvent_); 262 EXPECT_TRUE(cpuDetailParser_->CpuIdleEvent(eventInfo_)); 263 } 264 /** 265 * @tc.name: ParseCpuFrequencyEvent 266 * @tc.desc: Test CpuDetailParser: Parse CpuFrequencyEvent 267 * @tc.type: FUNC 268 */ 269 HWTEST_F(RawtraceCpuDetailParserTest, ParseCpuFrequencyEvent, TestSize.Level1) 270 { 271 TS_LOGI("test39-18"); 272 EXPECT_TRUE(FtraceEventProcessor::GetInstance().CpuFrequency(*ftraceEvent_, data_.data(), data_.size(), format_)); 273 eventInfo_.msgPtr = std::move(ftraceEvent_); 274 EXPECT_TRUE(cpuDetailParser_->CpuFrequencyEvent(eventInfo_)); 275 } 276 /** 277 * @tc.name: ParseCpuFrequencyLimitsEvent 278 * @tc.desc: Test CpuDetailParser: Parse CpuFrequencyLimitsEvent 279 * @tc.type: FUNC 280 */ 281 HWTEST_F(RawtraceCpuDetailParserTest, ParseCpuFrequencyLimitsEvent, TestSize.Level1) 282 { 283 TS_LOGI("test39-19"); 284 EXPECT_TRUE( 285 FtraceEventProcessor::GetInstance().CpuFrequencyLimits(*ftraceEvent_, data_.data(), data_.size(), format_)); 286 eventInfo_.msgPtr = std::move(ftraceEvent_); 287 EXPECT_TRUE(cpuDetailParser_->CpuFrequencyLimitsEvent(eventInfo_)); 288 } 289 /** 290 * @tc.name: ParseSuspendResumeEvent 291 * @tc.desc: Test CpuDetailParser: Parse SuspendResumeEvent 292 * @tc.type: FUNC 293 */ 294 HWTEST_F(RawtraceCpuDetailParserTest, ParseSuspendResumeEvent, TestSize.Level1) 295 { 296 TS_LOGI("test39-20"); 297 EXPECT_TRUE(FtraceEventProcessor::GetInstance().SuspendResume(*ftraceEvent_, data_.data(), data_.size(), format_)); 298 eventInfo_.msgPtr = std::move(ftraceEvent_); 299 EXPECT_TRUE(cpuDetailParser_->SuspendResumeEvent(eventInfo_)); 300 } 301 /** 302 * @tc.name: ParseWorkqueueExecuteStartEvent 303 * @tc.desc: Test CpuDetailParser: Parse WorkqueueExecuteStartEvents 304 * @tc.type: FUNC 305 */ 306 HWTEST_F(RawtraceCpuDetailParserTest, ParseWorkqueueExecuteStartEvent, TestSize.Level1) 307 { 308 TS_LOGI("test39-21"); 309 EXPECT_TRUE( 310 FtraceEventProcessor::GetInstance().WorkqueueExecuteStart(*ftraceEvent_, data_.data(), data_.size(), format_)); 311 eventInfo_.msgPtr = std::move(ftraceEvent_); 312 EXPECT_TRUE(cpuDetailParser_->WorkqueueExecuteStartEvent(eventInfo_)); 313 } 314 /** 315 * @tc.name: ParseWorkqueueExecuteEndEvent 316 * @tc.desc: Test CpuDetailParser: Parse WorkqueueExecuteEndEvent 317 * @tc.type: FUNC 318 */ 319 HWTEST_F(RawtraceCpuDetailParserTest, ParseWorkqueueExecuteEndEvent, TestSize.Level1) 320 { 321 TS_LOGI("test39-22"); 322 EXPECT_TRUE( 323 FtraceEventProcessor::GetInstance().WorkqueueExecuteEnd(*ftraceEvent_, data_.data(), data_.size(), format_)); 324 eventInfo_.msgPtr = std::move(ftraceEvent_); 325 EXPECT_TRUE(cpuDetailParser_->WorkqueueExecuteEndEvent(eventInfo_)); 326 } 327 /** 328 * @tc.name: ParseIrqHandlerEntryEvent 329 * @tc.desc: Test CpuDetailParser: Parse IrqHandlerEntryEvent 330 * @tc.type: FUNC 331 */ 332 HWTEST_F(RawtraceCpuDetailParserTest, ParseIrqHandlerEntryEvent, TestSize.Level1) 333 { 334 TS_LOGI("test39-23"); 335 EXPECT_TRUE( 336 FtraceEventProcessor::GetInstance().IrqHandlerEntry(*ftraceEvent_, data_.data(), data_.size(), format_)); 337 eventInfo_.msgPtr = std::move(ftraceEvent_); 338 EXPECT_TRUE(cpuDetailParser_->IrqHandlerEntryEvent(eventInfo_)); 339 } 340 /** 341 * @tc.name: ParseIrqHandlerExitEvent 342 * @tc.desc: Test CpuDetailParser: Parse IrqHandlerExitEvent 343 * @tc.type: FUNC 344 */ 345 HWTEST_F(RawtraceCpuDetailParserTest, ParseIrqHandlerExitEvent, TestSize.Level1) 346 { 347 TS_LOGI("test39-24"); 348 EXPECT_TRUE(FtraceEventProcessor::GetInstance().IrqHandlerExit(*ftraceEvent_, data_.data(), data_.size(), format_)); 349 eventInfo_.msgPtr = std::move(ftraceEvent_); 350 EXPECT_TRUE(cpuDetailParser_->IrqHandlerExitEvent(eventInfo_)); 351 } 352 /** 353 * @tc.name: ParseIpiHandlerEntryEvent 354 * @tc.desc: Test CpuDetailParser: Parse IpiHandlerEntryEvent 355 * @tc.type: FUNC 356 */ 357 HWTEST_F(RawtraceCpuDetailParserTest, ParseIpiHandlerEntryEvent, TestSize.Level1) 358 { 359 TS_LOGI("test39-25"); 360 EXPECT_TRUE(FtraceEventProcessor::GetInstance().IpiEntry(*ftraceEvent_, data_.data(), data_.size(), format_)); 361 eventInfo_.msgPtr = std::move(ftraceEvent_); 362 EXPECT_TRUE(cpuDetailParser_->IpiHandlerEntryEvent(eventInfo_)); 363 } 364 /** 365 * @tc.name: ParseIpiHandlerExitEvent 366 * @tc.desc: Test CpuDetailParser: Parse IpiHandlerExitEvent 367 * @tc.type: FUNC 368 */ 369 HWTEST_F(RawtraceCpuDetailParserTest, ParseIpiHandlerExitEvent, TestSize.Level1) 370 { 371 TS_LOGI("test39-26"); 372 EXPECT_TRUE(FtraceEventProcessor::GetInstance().IpiExit(*ftraceEvent_, data_.data(), data_.size(), format_)); 373 eventInfo_.msgPtr = std::move(ftraceEvent_); 374 EXPECT_TRUE(cpuDetailParser_->IpiHandlerExitEvent(eventInfo_)); 375 } 376 /** 377 * @tc.name: ParseSoftIrqEntryEvent 378 * @tc.desc: Test CpuDetailParser: Parse SoftIrqEntryEvent 379 * @tc.type: FUNC 380 */ 381 HWTEST_F(RawtraceCpuDetailParserTest, ParseSoftIrqEntryEvent, TestSize.Level1) 382 { 383 TS_LOGI("test39-27"); 384 EXPECT_TRUE(FtraceEventProcessor::GetInstance().SoftirqEntry(*ftraceEvent_, data_.data(), data_.size(), format_)); 385 eventInfo_.msgPtr = std::move(ftraceEvent_); 386 EXPECT_TRUE(cpuDetailParser_->SoftIrqEntryEvent(eventInfo_)); 387 } 388 /** 389 * @tc.name: ParseSoftIrqRaiseEvent 390 * @tc.desc: Test CpuDetailParser: Parse SoftIrqRaiseEvent 391 * @tc.type: FUNC 392 */ 393 HWTEST_F(RawtraceCpuDetailParserTest, ParseSoftIrqRaiseEvent, TestSize.Level1) 394 { 395 TS_LOGI("test39-28"); 396 EXPECT_TRUE(FtraceEventProcessor::GetInstance().SoftirqRaise(*ftraceEvent_, data_.data(), data_.size(), format_)); 397 eventInfo_.msgPtr = std::move(ftraceEvent_); 398 EXPECT_TRUE(cpuDetailParser_->SoftIrqRaiseEvent(eventInfo_)); 399 } 400 /** 401 * @tc.name: ParseSoftIrqExitEvent 402 * @tc.desc: Test CpuDetailParser: Parse SoftIrqExitEvent 403 * @tc.type: FUNC 404 */ 405 HWTEST_F(RawtraceCpuDetailParserTest, ParseSoftIrqExitEvent, TestSize.Level1) 406 { 407 TS_LOGI("test39-29"); 408 EXPECT_TRUE(FtraceEventProcessor::GetInstance().SoftirqExit(*ftraceEvent_, data_.data(), data_.size(), format_)); 409 eventInfo_.msgPtr = std::move(ftraceEvent_); 410 EXPECT_TRUE(cpuDetailParser_->SoftIrqExitEvent(eventInfo_)); 411 } 412 /** 413 * @tc.name: ParseSetRateEvent 414 * @tc.desc: Test CpuDetailParser: Parse SetRateEvent 415 * @tc.type: FUNC 416 */ 417 HWTEST_F(RawtraceCpuDetailParserTest, ParseSetRateEvent, TestSize.Level1) 418 { 419 TS_LOGI("test39-30"); 420 EXPECT_TRUE(FtraceEventProcessor::GetInstance().ClockSetRate(*ftraceEvent_, data_.data(), data_.size(), format_)); 421 eventInfo_.msgPtr = std::move(ftraceEvent_); 422 EXPECT_TRUE(cpuDetailParser_->SetRateEvent(eventInfo_)); 423 } 424 /** 425 * @tc.name: ParseClockEnableEvent 426 * @tc.desc: Test CpuDetailParser: Parse ClockEnableEvent 427 * @tc.type: FUNC 428 */ 429 HWTEST_F(RawtraceCpuDetailParserTest, ParseClockEnableEvent, TestSize.Level1) 430 { 431 TS_LOGI("test39-31"); 432 EXPECT_TRUE(FtraceEventProcessor::GetInstance().ClockEnable(*ftraceEvent_, data_.data(), data_.size(), format_)); 433 eventInfo_.msgPtr = std::move(ftraceEvent_); 434 EXPECT_TRUE(cpuDetailParser_->ClockEnableEvent(eventInfo_)); 435 } 436 /** 437 * @tc.name: ParseClockDisableEvent 438 * @tc.desc: Test CpuDetailParser: Parse ClockDisableEvent 439 * @tc.type: FUNC 440 */ 441 HWTEST_F(RawtraceCpuDetailParserTest, ParseClockDisableEvent, TestSize.Level1) 442 { 443 TS_LOGI("test39-32"); 444 EXPECT_TRUE(FtraceEventProcessor::GetInstance().ClockDisable(*ftraceEvent_, data_.data(), data_.size(), format_)); 445 eventInfo_.msgPtr = std::move(ftraceEvent_); 446 EXPECT_TRUE(cpuDetailParser_->ClockDisableEvent(eventInfo_)); 447 } 448 /** 449 * @tc.name: ParseRegulatorSetVoltageEvent 450 * @tc.desc: Test CpuDetailParser: Parse RegulatorSetVoltageEvent 451 * @tc.type: FUNC 452 */ 453 HWTEST_F(RawtraceCpuDetailParserTest, ParseRegulatorSetVoltageEvent, TestSize.Level1) 454 { 455 TS_LOGI("test39-33"); 456 EXPECT_TRUE( 457 FtraceEventProcessor::GetInstance().RegulatorSetVoltage(*ftraceEvent_, data_.data(), data_.size(), format_)); 458 eventInfo_.msgPtr = std::move(ftraceEvent_); 459 EXPECT_TRUE(cpuDetailParser_->RegulatorSetVoltageEvent(eventInfo_)); 460 } 461 /** 462 * @tc.name: ParseRegulatorSetVoltageCompleteEvent 463 * @tc.desc: Test CpuDetailParser: Parse RegulatorSetVoltageCompleteEvent 464 * @tc.type: FUNC 465 */ 466 HWTEST_F(RawtraceCpuDetailParserTest, ParseRegulatorSetVoltageCompleteEvent, TestSize.Level1) 467 { 468 TS_LOGI("test39-34"); 469 EXPECT_TRUE(FtraceEventProcessor::GetInstance().RegulatorSetVoltageComplete(*ftraceEvent_, data_.data(), 470 data_.size(), format_)); 471 eventInfo_.msgPtr = std::move(ftraceEvent_); 472 EXPECT_TRUE(cpuDetailParser_->RegulatorSetVoltageCompleteEvent(eventInfo_)); 473 } 474 /** 475 * @tc.name: ParseRegulatorDisableEvent 476 * @tc.desc: Test CpuDetailParser: Parse RegulatorDisableEvent 477 * @tc.type: FUNC 478 */ 479 HWTEST_F(RawtraceCpuDetailParserTest, ParseRegulatorDisableEvent, TestSize.Level1) 480 { 481 TS_LOGI("test39-35"); 482 EXPECT_TRUE( 483 FtraceEventProcessor::GetInstance().RegulatorDisable(*ftraceEvent_, data_.data(), data_.size(), format_)); 484 eventInfo_.msgPtr = std::move(ftraceEvent_); 485 EXPECT_TRUE(cpuDetailParser_->RegulatorDisableEvent(eventInfo_)); 486 } 487 /** 488 * @tc.name: ParseRegulatorDisableCompleteEvent 489 * @tc.desc: Test CpuDetailParser: Parse RegulatorDisableCompleteEvent 490 * @tc.type: FUNC 491 */ 492 HWTEST_F(RawtraceCpuDetailParserTest, ParseRegulatorDisableCompleteEvent, TestSize.Level1) 493 { 494 TS_LOGI("test39-36"); 495 EXPECT_TRUE(FtraceEventProcessor::GetInstance().RegulatorDisableComplete(*ftraceEvent_, data_.data(), data_.size(), 496 format_)); 497 eventInfo_.msgPtr = std::move(ftraceEvent_); 498 EXPECT_TRUE(cpuDetailParser_->RegulatorDisableCompleteEvent(eventInfo_)); 499 } 500 } // namespace TraceStreamer 501 } // namespace SysTuning