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 <fcntl.h> 17 #include <hwext/gtest-ext.h> 18 #include <hwext/gtest-tag.h> 19 #include <string> 20 #include <unordered_map> 21 22 #include "cpu_filter.h" 23 #include "parser/ptreader_parser/bytrace_parser/bytrace_event_parser.h" 24 #include "parser/ptreader_parser/ptreader_parser.h" 25 #include "parser/common_types.h" 26 #include "string_help.h" 27 #include "trace_streamer_selector.h" 28 29 using namespace testing::ext; 30 using namespace SysTuning::TraceStreamer; 31 using namespace SysTuning::base; 32 33 namespace SysTuning { 34 namespace TraceStreamer { 35 const uint32_t G_BUF_SIZE = 1024; 36 // TestSuite: 37 class EventParserTest : public ::testing::Test { 38 public: SetUp()39 void SetUp() 40 { 41 stream_.InitFilter(); 42 } 43 TearDown()44 void TearDown() 45 { 46 if (access(dbPath_.c_str(), F_OK) == 0) { 47 remove(dbPath_.c_str()); 48 } 49 } 50 51 public: 52 TraceStreamerSelector stream_ = {}; 53 const std::string dbPath_ = "../../../data/resource/out.db"; 54 }; 55 56 /** 57 * @tc.name: ParseLine 58 * @tc.desc: Parse a complete sched_switch event in bytrace format 59 * @tc.type: FUNC 60 */ 61 HWTEST_F(EventParserTest, ParseLine, TestSize.Level1) 62 { 63 TS_LOGI("test5-1"); 64 BytraceLine bytraceLine; 65 bytraceLine.ts = 1616439852302; 66 bytraceLine.pid = 1; 67 bytraceLine.cpu = 0; 68 bytraceLine.task = "ACCS0-2716"; 69 bytraceLine.eventName = "sched_switch"; 70 bytraceLine.argsStr = 71 "prev_comm=ACCS0 prev_pid=2716 prev_prio=120 \ 72 prev_state=R ==> next_comm=kworker/0:0 next_pid=8326 next_prio=120"; 73 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 74 eventParser.ParseDataItem(bytraceLine); 75 eventParser.FilterAllEvents(); 76 EXPECT_EQ(0, 77 stream_.traceDataCache_->GetStatAndInfo()->GetValue(TRACE_EVENT_SCHED_SWITCH, STAT_EVENT_DATA_INVALID)); 78 auto readStatIndex = stream_.traceDataCache_->GetConstSchedSliceData().EndStatesData()[0]; 79 EXPECT_EQ(TASK_RUNNABLE, readStatIndex); 80 auto realTimeStamp = stream_.traceDataCache_->GetConstSchedSliceData().TimeStampData()[0]; 81 EXPECT_TRUE(bytraceLine.ts == realTimeStamp); 82 auto realCpu = stream_.traceDataCache_->GetConstSchedSliceData().CpusData()[0]; 83 EXPECT_TRUE(bytraceLine.cpu == realCpu); 84 } 85 86 /** 87 * @tc.name: ParseLineNotEnoughArgs 88 * @tc.desc: Parse a sched_switch event which has not enough args in bytrace format 89 * @tc.type: FUNC 90 */ 91 HWTEST_F(EventParserTest, ParseLineNotEnoughArgs, TestSize.Level1) 92 { 93 TS_LOGI("test5-2"); 94 BytraceLine bytraceLine; 95 bytraceLine.ts = 1616439852302; 96 bytraceLine.pid = 1; 97 bytraceLine.cpu = 0; 98 bytraceLine.task = "ACCS0-2716"; 99 bytraceLine.eventName = "sched_switch"; 100 bytraceLine.argsStr = "prev_state=R ==> next_comm=kworker/0:0 next_pid=8326 next_prio=120"; 101 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 102 eventParser.ParseDataItem(bytraceLine); 103 eventParser.FilterAllEvents(); 104 EXPECT_EQ(1, 105 stream_.traceDataCache_->GetStatAndInfo()->GetValue(TRACE_EVENT_SCHED_SWITCH, STAT_EVENT_DATA_INVALID)); 106 TS_LOGI("test5-2 Finished."); 107 } 108 /** 109 * @tc.name: ParseLineUnCognizableEventname 110 * @tc.desc: Parse a UnCognizable Eventname event in bytrace format 111 * @tc.type: FUNC 112 */ 113 HWTEST_F(EventParserTest, ParseLineUnCognizableEventname, TestSize.Level1) 114 { 115 TS_LOGI("test5-3"); 116 BytraceLine bytraceLine; 117 bytraceLine.ts = 1616439852302; 118 bytraceLine.pid = 1; 119 bytraceLine.cpu = 0; 120 bytraceLine.task = "ACCS0-2716"; 121 bytraceLine.eventName = "ThisEventNameDoNotExist"; // UnRecognizable event name 122 bytraceLine.argsStr = 123 "prev_comm=ACCS0 prev_pid=2716 prev_prio=120 \ 124 prev_state=R ==> next_comm=kworker/0:0 next_pid=8326 next_prio=120"; 125 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 126 eventParser.ParseDataItem(bytraceLine); 127 eventParser.FilterAllEvents(); 128 EXPECT_EQ(1, stream_.traceDataCache_->GetStatAndInfo()->GetValue(TRACE_EVENT_OTHER, STAT_EVENT_NOTSUPPORTED)); 129 } 130 131 /** 132 * @tc.name: ParseSchedSwitchNoArgs 133 * @tc.desc: Parse a SchedSwitch event which has no args in bytrace format 134 * @tc.type: FUNC 135 */ 136 HWTEST_F(EventParserTest, ParseSchedSwitchNoArgs, TestSize.Level1) 137 { 138 TS_LOGI("test5-4"); 139 BytraceLine bytraceLine; 140 bytraceLine.ts = 1616439852302; 141 bytraceLine.pid = 1; 142 bytraceLine.cpu = 0; 143 bytraceLine.task = "ACCS0-2716"; 144 bytraceLine.eventName = "sched_switch"; 145 bytraceLine.argsStr = 146 "prev_comm=ACCS0 prev_pid=2716 prev_prio=120 \ 147 prev_state=R ==> next_comm=kworker/0:0 next_pid=8326 next_prio=120"; 148 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 149 eventParser.ParseDataItem(bytraceLine); 150 eventParser.FilterAllEvents(); 151 EXPECT_EQ(1, stream_.traceDataCache_->GetStatAndInfo()->GetValue(TRACE_EVENT_SCHED_SWITCH, STAT_EVENT_RECEIVED)); 152 } 153 154 /** 155 * @tc.name: ParseSchedWakeupNoArgs 156 * @tc.desc: Parse a SchedWakeup event which has no args in bytrace format 157 * @tc.type: FUNC 158 */ 159 HWTEST_F(EventParserTest, ParseSchedWakeupNoArgs, TestSize.Level1) 160 { 161 TS_LOGI("test5-5"); 162 BytraceLine bytraceLine; 163 bytraceLine.ts = 1616439852302; 164 bytraceLine.pid = 1; 165 bytraceLine.cpu = 0; 166 bytraceLine.task = "ACCS0-2716"; 167 bytraceLine.eventName = "sched_wakeup"; 168 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 169 eventParser.ParseDataItem(bytraceLine); 170 eventParser.FilterAllEvents(); 171 EXPECT_EQ(1, 172 stream_.traceDataCache_->GetStatAndInfo()->GetValue(TRACE_EVENT_SCHED_WAKEUP, STAT_EVENT_DATA_INVALID)); 173 } 174 175 /** 176 * @tc.name: ParseTracingMarkWriteC 177 * @tc.desc: Parse a TracingMarkWrite C event 178 * @tc.type: FUNC 179 */ 180 HWTEST_F(EventParserTest, ParseTracingMarkWriteC, TestSize.Level1) 181 { 182 TS_LOGI("test5-6"); 183 184 const uint8_t str[] = 185 "ACCS0-2716 ( 2519) [000] ...1 174330.284808: tracing_mark_write: C|2519|Heap size (KB)|2906\n"; 186 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 187 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 188 EXPECT_TRUE(false); 189 return; 190 } 191 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 192 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 193 ptreaderParser.WaitForParserEnd(); 194 195 EXPECT_EQ(ptreaderParser.ParsedTraceValidLines(), static_cast<const uint32_t>(1)); 196 EXPECT_EQ(2906, stream_.traceDataCache_->GetProcessMeasureData()->ValuesData()[0]); 197 } 198 199 /** 200 * @tc.name: ParseTracingMarkWriteBE 201 * @tc.desc: Parse a TracingMarkWrite BE event 202 * @tc.type: FUNC 203 */ 204 HWTEST_F(EventParserTest, ParseTracingMarkWriteBE, TestSize.Level1) 205 { 206 TS_LOGI("test5-7"); 207 const uint8_t str[] = 208 "system-1298 ( 1298) [001] ...1 174330.287420: tracing_mark_write: B|1298|Choreographer#doFrame\n" 209 "system-1298 ( 1298) [001] ...1 174330.287622: tracing_mark_write: E|1298\n"; 210 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 211 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 212 EXPECT_TRUE(false); 213 return; 214 } 215 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 216 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 217 ptreaderParser.WaitForParserEnd(); 218 219 EXPECT_EQ(ptreaderParser.ParsedTraceValidLines(), static_cast<const uint32_t>(2)); 220 EXPECT_EQ(174330287420000, stream_.traceDataCache_->GetInternalSlicesData()->TimeStampData()[0]); 221 EXPECT_EQ(202000, stream_.traceDataCache_->GetInternalSlicesData()->DursData()[0]); 222 } 223 224 /** 225 * @tc.name: ParseTracingMarkWriteSF 226 * @tc.desc: Parse a TracingMarkWrite SF event 227 * @tc.type: FUNC 228 */ 229 HWTEST_F(EventParserTest, ParseTracingMarkWriteSF, TestSize.Level1) 230 { 231 TS_LOGI("test5-8"); 232 233 const uint8_t str[] = 234 "system-1298 ( 1298) [001] ...1 174330.287478: tracing_mark_write: S|1298|animator:translateX|18888109\n" 235 "system-1298 ( 1298) [001] ...1 174330.287514: tracing_mark_write: F|1298|animator:translateX|18888109\n"; 236 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 237 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 238 EXPECT_TRUE(false); 239 return; 240 } 241 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 242 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 243 ptreaderParser.WaitForParserEnd(); 244 245 EXPECT_EQ(ptreaderParser.ParsedTraceValidLines(), static_cast<const uint32_t>(2)); 246 EXPECT_EQ(174330287478000, stream_.traceDataCache_->GetInternalSlicesData()->TimeStampData()[0]); 247 EXPECT_EQ(36000, stream_.traceDataCache_->GetInternalSlicesData()->DursData()[0]); 248 EXPECT_EQ(18888109, stream_.traceDataCache_->GetInternalSlicesData()->Cookies()[0]); 249 } 250 251 /** 252 * @tc.name: ParseTracingMarkWriteErrorPoint 253 * @tc.desc: Parse a TracingMarkWrite event with error point info 254 * @tc.type: FUNC 255 */ 256 HWTEST_F(EventParserTest, ParseTracingMarkWriteErrorPoint, TestSize.Level1) 257 { 258 TS_LOGI("test5-9"); 259 const uint8_t str[] = 260 "system-1298 ( 1298) [001] ...1 174330.287478: tracing_mark_write: G|1298|animator:translateX|18888109\n"; 261 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 262 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 263 EXPECT_TRUE(false); 264 return; 265 } 266 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 267 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 268 ptreaderParser.WaitForParserEnd(); 269 EXPECT_EQ(0, stream_.traceDataCache_->GetInternalSlicesData()->TimeStampData().size()); 270 } 271 272 /** 273 * @tc.name: ParseCpuIdle 274 * @tc.desc: Parse a CpuIdle event 275 * @tc.type: FUNC 276 */ 277 HWTEST_F(EventParserTest, ParseCpuIdle, TestSize.Level1) 278 { 279 TS_LOGI("test5-10"); 280 const uint8_t str[] = "<idle>-0 (-----) [003] d..2 174330.280761: cpu_idle: state=2 cpu_id=3\n"; 281 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 282 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 283 EXPECT_TRUE(false); 284 return; 285 } 286 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 287 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 288 ptreaderParser.WaitForParserEnd(); 289 290 EXPECT_EQ(ptreaderParser.ParsedTraceValidLines(), static_cast<const uint32_t>(1)); 291 EXPECT_EQ(174330280761000, stream_.traceDataCache_->GetMeasureData()->TimeStampData()[0]); 292 EXPECT_EQ(3, stream_.traceDataCache_->GetMeasureData()->ValuesData()[0]); 293 } 294 295 /** 296 * @tc.name: ParseIrqHandlerEntry 297 * @tc.desc: Parse a IrqHandlerEntry event 298 * @tc.type: FUNC 299 */ 300 HWTEST_F(EventParserTest, ParseIrqHandlerEntry, TestSize.Level1) 301 { 302 TS_LOGI("test5-11"); 303 const uint8_t str[] = 304 "ACCS0-2716 ( 2519) [000] d.h1 174330.280362: irq_handler_entry: irq=19 name=408000.qcom,cpu-bwmon\n"; 305 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 306 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 307 EXPECT_TRUE(false); 308 return; 309 } 310 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 311 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 312 ptreaderParser.WaitForParserEnd(); 313 314 EXPECT_EQ(ptreaderParser.ParsedTraceValidLines(), static_cast<const uint32_t>(1)); 315 EXPECT_EQ(174330280362000, stream_.traceDataCache_->GetIrqData()->TimeStampData()[0]); 316 } 317 318 /** 319 * @tc.name: ParseIrqHandlerExit 320 * @tc.desc: Parse a IrqHandlerExit event 321 * @tc.type: FUNC 322 */ 323 HWTEST_F(EventParserTest, ParseIrqHandlerExit, TestSize.Level1) 324 { 325 TS_LOGI("test5-12"); 326 const uint8_t str[] = 327 "ACCS0-2716 ( 2519) [000] d.h1 174330.280362: irq_handler_entry: irq=19 name=408000.qcom,cpu-bwmon\n" 328 "ACCS0-2716 ( 2519) [000] d.h1 174330.280382: irq_handler_exit: irq=19 ret=handled\n"; 329 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 330 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 331 EXPECT_TRUE(false); 332 return; 333 } 334 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 335 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 336 ptreaderParser.WaitForParserEnd(); 337 338 EXPECT_EQ(ptreaderParser.ParsedTraceValidLines(), static_cast<const uint32_t>(2)); 339 EXPECT_EQ(1, 340 stream_.traceDataCache_->GetStatAndInfo()->GetValue(TRACE_EVENT_IRQ_HANDLER_EXIT, STAT_EVENT_RECEIVED)); 341 } 342 343 /** 344 * @tc.name: ParseSchedWaking 345 * @tc.desc: Parse a SchedWaking event 346 * @tc.type: FUNC 347 */ 348 HWTEST_F(EventParserTest, ParseSchedWaking, TestSize.Level1) 349 { 350 TS_LOGI("test5-13"); 351 const uint8_t str[] = 352 "ACCS0-2716 ( 2519) [000] d..5 174330.280567: sched_waking: \ 353 comm=Binder:924_6 pid=1332 prio=120 target_cpu=000\n"; 354 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 355 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 356 EXPECT_TRUE(false); 357 return; 358 } 359 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 360 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 361 ptreaderParser.WaitForParserEnd(); 362 EXPECT_EQ(ptreaderParser.ParsedTraceValidLines(), static_cast<const uint32_t>(1)); 363 EXPECT_EQ(0, stream_.traceDataCache_->GetSchedSliceData()->TimeStampData().size()); 364 } 365 366 /** 367 * @tc.name: ParseSchedWakeup 368 * @tc.desc: Parse a SchedWakeup event 369 * @tc.type: FUNC 370 */ 371 HWTEST_F(EventParserTest, ParseSchedWakeup, TestSize.Level1) 372 { 373 TS_LOGI("test5-14"); 374 const uint8_t str[] = 375 "ACCS0-2716 ( 2519) [000] d..6 174330.280575: sched_wakeup: \ 376 comm=Binder:924_6 pid=1332 prio=120 target_cpu=000\n"; 377 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 378 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 379 EXPECT_TRUE(false); 380 return; 381 } 382 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 383 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 384 ptreaderParser.WaitForParserEnd(); 385 386 EXPECT_EQ(ptreaderParser.ParsedTraceValidLines(), static_cast<const uint32_t>(1)); 387 EXPECT_EQ(174330280575000, stream_.traceDataCache_->GetRawData()->TimeStampData()[0]); 388 EXPECT_EQ(0, stream_.traceDataCache_->GetRawData()->CpuData()[0]); 389 } 390 391 /** 392 * @tc.name: ParseTraceEventClockSync 393 * @tc.desc: Parse a TraceEventClockSync event 394 * @tc.type: FUNC 395 */ 396 HWTEST_F(EventParserTest, ParseTraceEventClockSync, TestSize.Level1) 397 { 398 TS_LOGI("test5-15"); 399 const uint8_t str[] = 400 "sampletrace-12728 (12728) [003] ...1 174330.280300: tracing_mark_write: \ 401 trace_event_clock_sync:parent_ts=23139.998047\n"; 402 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 403 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 404 EXPECT_TRUE(false); 405 return; 406 } 407 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 408 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 409 ptreaderParser.WaitForParserEnd(); 410 411 EXPECT_EQ(ptreaderParser.ParsedTraceValidLines(), static_cast<const uint32_t>(1)); 412 EXPECT_EQ(1, 413 stream_.traceDataCache_->GetStatAndInfo()->GetValue(TRACE_EVENT_TRACING_MARK_WRITE, STAT_EVENT_RECEIVED)); 414 EXPECT_EQ(1, stream_.traceDataCache_->GetStatAndInfo()->GetValue(TRACE_EVENT_TRACING_MARK_WRITE, 415 STAT_EVENT_DATA_INVALID)); 416 } 417 418 /** 419 * @tc.name: ParseSchedSwitch 420 * @tc.desc: Parse a SchedSwitch event 421 * @tc.type: FUNC 422 */ 423 HWTEST_F(EventParserTest, ParseSchedSwitch, TestSize.Level1) 424 { 425 TS_LOGI("test5-16"); 426 const uint8_t str[] = 427 "ACCS0-2716 ( 2519) [000] d..3 174330.289220: sched_switch: prev_comm=ACCS0 prev_pid=2716 prev_prio=120 \ 428 prev_state=R+ ==> next_comm=Binder:924_6 next_pid=1332 next_prio=120\n"; 429 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 430 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 431 EXPECT_TRUE(false); 432 return; 433 } 434 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 435 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 436 ptreaderParser.WaitForParserEnd(); 437 438 EXPECT_EQ(ptreaderParser.ParsedTraceValidLines(), static_cast<const uint32_t>(1)); 439 EXPECT_EQ(174330289220000, stream_.traceDataCache_->GetSchedSliceData()->TimeStampData()[0]); 440 } 441 442 /** 443 * @tc.name: ParseTaskRename 444 * @tc.desc: Parse a TaskRename event 445 * @tc.type: FUNC 446 */ 447 HWTEST_F(EventParserTest, ParseTaskRename, TestSize.Level1) 448 { 449 TS_LOGI("test5-17"); 450 const uint8_t str[] = 451 "ACCS0-12729 ( 2519) [000] d..3 174330.289220: sched_switch: prev_comm=ACCS0\ 452 prev_pid=2716 prev_prio=120 prev_state=R+ ==> next_comm=Binder:924_6 next_pid=1332 next_prio=120\n\ 453 <...>-2093 (-----) [001] ...2 174332.792290: task_rename: pid=12729 oldcomm=perfd \ 454 newcomm=POSIX timer 249 oom_score_adj=-1000\n"; 455 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 456 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 457 EXPECT_TRUE(false); 458 return; 459 } 460 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 461 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 462 ptreaderParser.WaitForParserEnd(); 463 464 auto itid = stream_.streamFilters_->processFilter_->GetInternalTid(12729); 465 auto threadNameIndex = stream_.traceDataCache_->GetThreadData(itid)->nameIndex_; 466 auto expectThreadNameIndex = stream_.traceDataCache_->GetDataIndex("POSIX"); 467 EXPECT_EQ(expectThreadNameIndex, threadNameIndex); 468 } 469 470 /** 471 * @tc.name: ParseTaskNewtask 472 * @tc.desc: Parse a TaskNewtask event 473 * @tc.type: FUNC 474 */ 475 HWTEST_F(EventParserTest, ParseTaskNewtask, TestSize.Level1) 476 { 477 TS_LOGI("test5-18"); 478 const uint8_t str[] = 479 "<...>-2 (-----) [003] ...1 174332.825588: task_newtask: pid=12730 \ 480 comm=kthreadd clone_flags=800711 oom_score_adj=0\n"; 481 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 482 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 483 EXPECT_TRUE(false); 484 return; 485 } 486 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 487 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 488 ptreaderParser.WaitForParserEnd(); 489 490 EXPECT_EQ(ptreaderParser.ParsedTraceValidLines(), static_cast<const uint32_t>(1)); 491 auto itid = stream_.streamFilters_->processFilter_->GetInternalTid(12730); 492 EXPECT_EQ(INVALID_ID, itid); 493 } 494 495 /** 496 * @tc.name: ParseWorkqueueExecuteStart 497 * @tc.desc: Parse a WorkqueueExecuteStart event 498 * @tc.type: FUNC 499 */ 500 HWTEST_F(EventParserTest, ParseWorkqueueExecuteStart, TestSize.Level1) 501 { 502 TS_LOGI("test5-19"); 503 const uint8_t str[] = 504 "<...>-12180 (-----) [001] ...1 174332.827595: workqueue_execute_start: \ 505 work struct 0000000000000000: function pm_runtime_work\n"; 506 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 507 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 508 EXPECT_TRUE(false); 509 return; 510 } 511 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 512 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 513 ptreaderParser.WaitForParserEnd(); 514 515 EXPECT_EQ(ptreaderParser.ParsedTraceValidLines(), static_cast<const uint32_t>(1)); 516 EXPECT_EQ(174332827595000, stream_.traceDataCache_->GetInternalSlicesData()->TimeStampData()[0]); 517 } 518 519 /** 520 * @tc.name: ParseWorkqueueExecuteEnd 521 * @tc.desc: Parse a WorkqueueExecuteEnd event 522 * @tc.type: FUNC 523 */ 524 HWTEST_F(EventParserTest, ParseWorkqueueExecuteEnd, TestSize.Level1) 525 { 526 TS_LOGI("test5-20"); 527 const uint8_t str[] = 528 "<...>-12180 (-----) [001] ...1 174332.827595: workqueue_execute_start: \ 529 work struct 0000000000000000: function pm_runtime_work\n\ 530 <...>-12180 (-----) [001] ...1 174332.828056: workqueue_execute_end: work struct 0000000000000000\n"; 531 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 532 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 533 EXPECT_TRUE(false); 534 return; 535 } 536 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 537 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 538 ptreaderParser.WaitForParserEnd(); 539 540 EXPECT_EQ(174332827595000, stream_.traceDataCache_->GetInternalSlicesData()->TimeStampData()[0]); 541 EXPECT_EQ(461000, stream_.traceDataCache_->GetInternalSlicesData()->DursData()[0]); 542 } 543 544 /** 545 * @tc.name: ParsDistribute 546 * @tc.desc: Parse a Distribute event 547 * @tc.type: FUNC 548 */ 549 HWTEST_F(EventParserTest, ParsDistribute, TestSize.Level1) 550 { 551 TS_LOGI("test5-21"); 552 const uint8_t str[] = 553 "system-1298 ( 1298) [001] ...1 174330.287420: tracing_mark_write: B|1298|H:[8b00e96b2,2,1]#C##decodeFrame\n" 554 "system - 1298(1298)[001]... 1 174330.287622 : tracing_mark_write : E | 1298 \n"; 555 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 556 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 557 EXPECT_TRUE(false); 558 return; 559 } 560 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 561 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 562 ptreaderParser.WaitForParserEnd(); 563 564 EXPECT_EQ(ptreaderParser.ParsedTraceValidLines(), static_cast<const uint32_t>(1)); 565 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 566 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ChainIds()[0] == "8b00e96b2"); 567 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().SpanIds()[0] == "2"); 568 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ParentSpanIds()[0] == "1"); 569 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Flags()[0] == "C"); 570 } 571 572 /** 573 * @tc.name: ParsPairsOfDistributeEvent 574 * @tc.desc: Parse a pair of Distribute event 575 * @tc.type: FUNC 576 */ 577 HWTEST_F(EventParserTest, ParsPairsOfDistributeEvent, TestSize.Level1) 578 { 579 TS_LOGI("test5-22"); 580 const uint8_t str[] = 581 "system-1298 ( 1298) [001] ...1 174330.287420: tracing_mark_write: B|1298|H:[8b00e96b2,2,1]#C##decodeFrame\n" 582 "startVC-7601 ( 7601) [002] ...1 174330.387420: tracing_mark_write: B|7601|H:[8b00e96b2,2,1]#S##startVCFrame\n"; 583 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 584 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 585 EXPECT_TRUE(false); 586 return; 587 } 588 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 589 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 590 ptreaderParser.WaitForParserEnd(); 591 592 EXPECT_EQ(ptreaderParser.ParsedTraceValidLines(), static_cast<const uint32_t>(2)); 593 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 2); 594 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ChainIds()[0] == "8b00e96b2"); 595 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().SpanIds()[0] == "2"); 596 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ParentSpanIds()[0] == "1"); 597 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Flags()[0] == "C"); 598 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ChainIds()[1] == "8b00e96b2"); 599 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().SpanIds()[1] == "2"); 600 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ParentSpanIds()[1] == "1"); 601 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Flags()[1] == "S"); 602 } 603 604 /** 605 * @tc.name: ParsDistributeWithNoFlag 606 * @tc.desc: Parse a Distribute event with no flag 607 * @tc.type: FUNC 608 */ 609 HWTEST_F(EventParserTest, ParsDistributeWithNoFlag, TestSize.Level1) 610 { 611 TS_LOGI("test5-23"); 612 const uint8_t str[] = 613 "system-1298 ( 1298) [001] ...1 174330.287420: tracing_mark_write: B|1298|H:[8b00e96b2,2,1]###decodeFrame\n" 614 "system - 1298(1298)[001]... 1 174330.287622 : tracing_mark_write : E | 1298 \n"; 615 auto buf = std::make_unique<uint8_t[]>(G_BUF_SIZE); 616 if (memcpy_s(buf.get(), G_BUF_SIZE, str, sizeof(str))) { 617 EXPECT_TRUE(false); 618 return; 619 } 620 PtreaderParser ptreaderParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 621 ptreaderParser.ParseTraceDataSegment(std::move(buf), G_BUF_SIZE); 622 ptreaderParser.WaitForParserEnd(); 623 624 EXPECT_EQ(ptreaderParser.ParsedTraceValidLines(), static_cast<const uint32_t>(1)); 625 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 626 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ChainIds()[0] == "8b00e96b2"); 627 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().SpanIds()[0] == "2"); 628 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ParentSpanIds()[0] == "1"); 629 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Flags()[0] == ""); 630 } 631 632 /** 633 * @tc.name: ParseSchedSwitchByInitParam 634 * @tc.desc: Parse a SchedSwitch event 635 * @tc.type: FUNC 636 */ 637 HWTEST_F(EventParserTest, ParseSchedSwitchByInitParam, TestSize.Level1) 638 { 639 TS_LOGI("test5-24"); 640 BytraceLine bytraceLine; 641 static std::unordered_map<std::string, std::string> args{{"prev_comm", "ACCS0"}, {"next_comm", "HeapTaskDaemon"}, 642 {"prev_prio", "120"}, {"next_prio", "124"}, 643 {"prev_pid", "2716"}, {"next_pid", "2532"}, 644 {"prev_state", "S"}}; 645 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 646 int32_t result = eventParser.SchedSwitchEvent(args, bytraceLine); 647 648 EXPECT_EQ(result, true); 649 } 650 651 /** 652 * @tc.name: ParseSchedSwitchByAbnormalInitParam 653 * @tc.desc: Parse a SchedSwitch event with some Null parameter 654 * @tc.type: FUNC 655 */ 656 HWTEST_F(EventParserTest, ParseSchedSwitchByAbnormalInitParam, TestSize.Level1) 657 { 658 TS_LOGI("test5-25"); 659 BytraceLine bytraceLine; 660 static std::unordered_map<std::string, std::string> args{{"prev_comm", "ACCS0"}, {"next_comm", "HeapTaskDaemon"}, 661 {"prev_prio", ""}, {"next_prio", ""}, 662 {"prev_pid", ""}, {"next_pid", ""}, 663 {"prev_state", "S"}}; 664 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 665 int32_t result = eventParser.SchedSwitchEvent(args, bytraceLine); 666 667 EXPECT_EQ(result, false); 668 } 669 670 /** 671 * @tc.name: ParseTaskRenameEventByInitParam 672 * @tc.desc: Parse a TaskRename event 673 * @tc.type: FUNC 674 */ 675 HWTEST_F(EventParserTest, ParseTaskRenameEventByInitParam, TestSize.Level1) 676 { 677 TS_LOGI("test5-26"); 678 BytraceLine bytraceLine; 679 static std::unordered_map<std::string, std::string> args{{"newcomm", "POSIX"}, {"pid", "8542"}}; 680 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 681 int32_t result = eventParser.TaskRenameEvent(args, bytraceLine); 682 683 EXPECT_EQ(result, true); 684 } 685 686 /** 687 * @tc.name: ParseTaskNewtaskByInitParam 688 * @tc.desc: Parse a TaskNew event 689 * @tc.type: FUNC 690 */ 691 HWTEST_F(EventParserTest, ParseTaskNewtaskByInitParam, TestSize.Level1) 692 { 693 TS_LOGI("test5-27"); 694 BytraceLine bytraceLine; 695 static std::unordered_map<std::string, std::string> args{{"comm", "POSIX"}, {"pid", "8542"}, {"clone_flags", "1"}}; 696 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 697 int32_t result = eventParser.TaskNewtaskEvent(args, bytraceLine); 698 699 EXPECT_EQ(result, true); 700 } 701 702 /** 703 * @tc.name: ParseTracingMarkWriteByInitParam 704 * @tc.desc: Parse a TracingMarkWriteEvent event 705 * @tc.type: FUNC 706 */ 707 HWTEST_F(EventParserTest, ParseTracingMarkWriteByInitParam, TestSize.Level1) 708 { 709 TS_LOGI("test5-28"); 710 BytraceLine bytraceLine; 711 bytraceLine.ts = 1616439852302; 712 bytraceLine.pid = 1; 713 bytraceLine.argsStr = "B|924|FullSuspendCheck"; 714 static std::unordered_map<std::string, std::string> args{}; 715 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 716 int32_t result = eventParser.TracingMarkWriteOrPrintEvent(args, bytraceLine); 717 718 EXPECT_EQ(result, true); 719 } 720 721 /** 722 * @tc.name: ParseSchedWakeupByInitParam 723 * @tc.desc: Parse a SchedWakeup event 724 * @tc.type: FUNC 725 */ 726 HWTEST_F(EventParserTest, ParseSchedWakeupByInitParam, TestSize.Level1) 727 { 728 TS_LOGI("test5-29"); 729 BytraceLine bytraceLine; 730 bytraceLine.ts = 1616439852302; 731 bytraceLine.pid = 1; 732 static std::unordered_map<std::string, std::string> args{{"pid", "1200"}, {"target_cpu", "1"}}; 733 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 734 int32_t result = eventParser.SchedWakeupEvent(args, bytraceLine); 735 736 EXPECT_EQ(result, true); 737 } 738 739 /** 740 * @tc.name: ParseSchedWakeupByAbromalInitParam 741 * @tc.desc: Parse a SchedWakeup event 742 * @tc.type: FUNC 743 */ 744 HWTEST_F(EventParserTest, ParseSchedWakeupByAbromalInitParam, TestSize.Level1) 745 { 746 TS_LOGI("test5-30"); 747 BytraceLine bytraceLine; 748 bytraceLine.ts = 1616439852302; 749 bytraceLine.pid = 1; 750 static std::unordered_map<std::string, std::string> args{{"pid", ""}, {"target_cpu", "1"}}; 751 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 752 int32_t result = eventParser.SchedWakeupEvent(args, bytraceLine); 753 754 EXPECT_EQ(result, false); 755 } 756 757 /** 758 * @tc.name: ParseSchedWakingByInitParam 759 * @tc.desc: Parse a SchedWaking event 760 * @tc.type: FUNC 761 */ 762 HWTEST_F(EventParserTest, ParseSchedWakingByInitParam, TestSize.Level1) 763 { 764 TS_LOGI("test5-31"); 765 BytraceLine bytraceLine; 766 bytraceLine.ts = 1616439852302; 767 bytraceLine.pid = 1; 768 static std::unordered_map<std::string, std::string> args{ 769 {"prio", "120"}, {"comm", "thread1"}, {"pid", "1200"}, {"target_cpu", "1"}}; 770 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 771 int32_t result = eventParser.SchedWakingEvent(args, bytraceLine); 772 773 EXPECT_EQ(result, true); 774 } 775 776 /** 777 * @tc.name: ParseSchedWakingByAbnormalInitParam 778 * @tc.desc: Parse a SchedWaking event 779 * @tc.type: FUNC 780 */ 781 HWTEST_F(EventParserTest, ParseSchedWakingByAbnormalInitParam, TestSize.Level1) 782 { 783 TS_LOGI("test5-32"); 784 BytraceLine bytraceLine; 785 bytraceLine.ts = 1616439852302; 786 bytraceLine.pid = 1; 787 static std::unordered_map<std::string, std::string> args{ 788 {"prio", "120"}, {"comm", "thread1"}, {"pid", ""}, {"target_cpu", "1"}}; 789 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 790 int32_t result = eventParser.SchedWakingEvent(args, bytraceLine); 791 792 EXPECT_EQ(result, false); 793 } 794 795 /** 796 * @tc.name: ParseCpuIdleByInitParam 797 * @tc.desc: Parse a CpuIdle event 798 * @tc.type: FUNC 799 */ 800 HWTEST_F(EventParserTest, ParseCpuIdleByInitParam, TestSize.Level1) 801 { 802 TS_LOGI("test5-33"); 803 BytraceLine bytraceLine; 804 bytraceLine.ts = 1616439852302; 805 bytraceLine.eventName = "POSIX"; 806 static std::unordered_map<std::string, std::string> args{{"cpu_id", "3"}, {"state", "4294967295"}}; 807 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 808 int32_t result = eventParser.CpuIdleEvent(args, bytraceLine); 809 810 EXPECT_EQ(result, true); 811 } 812 813 /** 814 * @tc.name: ParseCpuIdleByAbnormalInitParam 815 * @tc.desc: Parse a CpuIdle event 816 * @tc.type: FUNC 817 */ 818 HWTEST_F(EventParserTest, ParseCpuIdleByAbnormalInitParam, TestSize.Level1) 819 { 820 TS_LOGI("test5-34"); 821 BytraceLine bytraceLine; 822 bytraceLine.ts = 1616439852302; 823 bytraceLine.eventName = "POSIX"; 824 static std::unordered_map<std::string, std::string> args{{"cpu_id", ""}, {"state", "4294967295"}}; 825 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 826 int32_t result = eventParser.CpuIdleEvent(args, bytraceLine); 827 828 EXPECT_EQ(result, false); 829 } 830 831 /** 832 * @tc.name: ParseCpuFrequencyNormal 833 * @tc.desc: Parse a CpuFrequency event normally 834 * @tc.type: FUNC 835 */ 836 HWTEST_F(EventParserTest, ParseCpuFrequencyNormal, TestSize.Level1) 837 { 838 TS_LOGI("test5-35"); 839 BytraceLine bytraceLine; 840 bytraceLine.ts = 1616439852302; 841 bytraceLine.eventName = "POSIX"; 842 static std::unordered_map<std::string, std::string> args{{"cpu_id", "3"}, {"state", "4294967295"}}; 843 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 844 int32_t result = eventParser.CpuFrequencyEvent(args, bytraceLine); 845 846 EXPECT_EQ(result, true); 847 } 848 849 /** 850 * @tc.name: ParseCpuFrequencyByAbnormalInitEmptyCpuId 851 * @tc.desc: Parse a CpuFrequency event 852 * @tc.type: FUNC 853 */ 854 HWTEST_F(EventParserTest, ParseCpuFrequencyByAbnormalInitEmptyCpuId, TestSize.Level1) 855 { 856 TS_LOGI("test5-36"); 857 BytraceLine bytraceLine; 858 bytraceLine.ts = 1616439852302; 859 bytraceLine.eventName = "POSIX"; 860 static std::unordered_map<std::string, std::string> args{{"cpu_id", ""}, {"state", "4294967295"}}; 861 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 862 int32_t result = eventParser.CpuFrequencyEvent(args, bytraceLine); 863 864 EXPECT_EQ(result, false); 865 } 866 867 /** 868 * @tc.name: ParseCpuFrequencyByAbnormalInitEmptyStateValue 869 * @tc.desc: Parse a CpuFrequency event, empty state value 870 * @tc.type: FUNC 871 */ 872 HWTEST_F(EventParserTest, ParseCpuFrequencyByAbnormalInitEmptyStateValue, TestSize.Level1) 873 { 874 TS_LOGI("test5-37"); 875 BytraceLine bytraceLine; 876 bytraceLine.ts = 1616439852302; 877 bytraceLine.eventName = "POSIX"; 878 static std::unordered_map<std::string, std::string> args{{"cpu_id", "3"}, {"state", ""}}; 879 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 880 int32_t result = eventParser.CpuFrequencyEvent(args, bytraceLine); 881 882 EXPECT_EQ(result, false); 883 } 884 885 /** 886 * @tc.name: ParseWorkqueueExecuteStartByInitParam 887 * @tc.desc: Parse a WorkqueueExecuteStart event 888 * @tc.type: FUNC 889 */ 890 HWTEST_F(EventParserTest, ParseWorkqueueExecuteStartByInitParam, TestSize.Level1) 891 { 892 TS_LOGI("test5-38"); 893 BytraceLine bytraceLine; 894 bytraceLine.ts = 1616439852302; 895 bytraceLine.pid = 1355; 896 bytraceLine.argsStr = "vec=9 [action=RCU]"; 897 static std::unordered_map<std::string, std::string> args{}; 898 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 899 int32_t result = eventParser.WorkqueueExecuteStartEvent(args, bytraceLine); 900 901 EXPECT_EQ(result, true); 902 } 903 904 /** 905 * @tc.name: ParseWorkqueueExecuteEndByInitParam 906 * @tc.desc: Parse a WorkqueueExecuteEnd event 907 * @tc.type: FUNC 908 */ 909 HWTEST_F(EventParserTest, ParseWorkqueueExecuteEndByInitParam, TestSize.Level1) 910 { 911 TS_LOGI("test5-39"); 912 BytraceLine bytraceLine; 913 bytraceLine.ts = 1616439852302; 914 bytraceLine.pid = 1355; 915 static std::unordered_map<std::string, std::string> args{}; 916 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 917 int32_t result = eventParser.WorkqueueExecuteEndEvent(args, bytraceLine); 918 919 EXPECT_EQ(result, true); 920 } 921 922 /** 923 * @tc.name: CheckTracePoint 924 * @tc.desc: Judge whether the "tracepoint information conforming to the specification" in a text format conforms to the 925 * tracepoint specification 926 * @tc.type: FUNC 927 */ 928 HWTEST_F(EventParserTest, CheckTracePoint, TestSize.Level1) 929 { 930 TS_LOGI("test5-40"); 931 std::string str("B|924|FullSuspendCheck"); 932 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 933 int32_t result = eventParser.printEventParser_.CheckTracePoint(str); 934 935 EXPECT_TRUE(result == PARSE_SUCCESS); 936 } 937 938 /** 939 * @tc.name: CheckTracePointEmptyString 940 * @tc.desc: Judge whether the Empty string conforms to the tracepoint specification 941 * @tc.type: FUNC 942 */ 943 HWTEST_F(EventParserTest, CheckTracePointEmptyString, TestSize.Level1) 944 { 945 TS_LOGI("test5-41"); 946 std::string str(""); 947 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 948 int32_t result = eventParser.printEventParser_.CheckTracePoint(str); 949 950 EXPECT_TRUE(result == PARSE_ERROR); 951 } 952 953 /** 954 * @tc.name: CheckTracePointNoSplit 955 * @tc.desc: Judge whether the string No Split conforms to the tracepoint specification 956 * @tc.type: FUNC 957 */ 958 HWTEST_F(EventParserTest, CheckTracePointNoSplit, TestSize.Level1) 959 { 960 TS_LOGI("test5-42"); 961 std::string str("trace_event_clock_sync"); 962 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 963 int32_t result = eventParser.printEventParser_.CheckTracePoint(str); 964 965 EXPECT_TRUE(result == PARSE_ERROR); 966 } 967 968 /** 969 * @tc.name: CheckTracePointMultiType 970 * @tc.desc: Judge whether the string has multipul Case type conforms to the tracepoint specification 971 * @tc.type: FUNC 972 */ 973 HWTEST_F(EventParserTest, CheckTracePointMultiType, TestSize.Level1) 974 { 975 TS_LOGI("test5-43"); 976 std::string str("BECSF|924|FullSuspendCheck"); 977 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 978 int32_t result = eventParser.printEventParser_.CheckTracePoint(str); 979 980 EXPECT_TRUE(result == PARSE_ERROR); 981 } 982 983 /** 984 * @tc.name: CheckTracePointCheckSingleCharacter 985 * @tc.desc: Check whether a single character conforms to tracepoint format 986 * @tc.type: FUNC 987 */ 988 HWTEST_F(EventParserTest, CheckTracePointCheckSingleCharacter, TestSize.Level1) 989 { 990 TS_LOGI("test5-44"); 991 std::string str("X"); 992 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 993 int32_t result = eventParser.printEventParser_.CheckTracePoint(str); 994 995 EXPECT_TRUE(result == PARSE_ERROR); 996 } 997 998 /** 999 * @tc.name: CheckTracePointCheckErrorSplit 1000 * @tc.desc: Check error split 1001 * @tc.type: FUNC 1002 */ 1003 HWTEST_F(EventParserTest, CheckTracePointCheckErrorSplit, TestSize.Level1) 1004 { 1005 TS_LOGI("test5-45"); 1006 std::string str("B&924|FullSuspendCheck"); 1007 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1008 int32_t result = eventParser.printEventParser_.CheckTracePoint(str); 1009 1010 EXPECT_TRUE(result == PARSE_ERROR); 1011 } 1012 1013 /** 1014 * @tc.name: GetTracePoint 1015 * @tc.desc: Test GetTracePoint interface 1016 * @tc.type: FUNC 1017 */ 1018 HWTEST_F(EventParserTest, GetTracePoint, TestSize.Level1) 1019 { 1020 TS_LOGI("test5-46"); 1021 TracePoint point; 1022 std::string str("B|924|SuspendThreadByThreadId suspended Binder:924_8 id=39"); 1023 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1024 int32_t result = eventParser.printEventParser_.GetTracePoint(str, point); 1025 1026 EXPECT_TRUE(result == PARSE_SUCCESS); 1027 } 1028 1029 /** 1030 * @tc.name: GetTracePointParseEmptyString 1031 * @tc.desc: Test GetTracePoint interface parse empty string 1032 * @tc.type: FUNC 1033 */ 1034 HWTEST_F(EventParserTest, GetTracePointParseEmptyString, TestSize.Level1) 1035 { 1036 TS_LOGI("test5-47"); 1037 TracePoint point; 1038 std::string str(""); 1039 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1040 int32_t result = eventParser.printEventParser_.GetTracePoint(str, point); 1041 1042 EXPECT_TRUE(result == PARSE_ERROR); 1043 } 1044 1045 /** 1046 * @tc.name: GetTracePointParseErrorSubEventType 1047 * @tc.desc: Test GetTracePoint interface parse error Sub event type 1048 * @tc.type: FUNC 1049 */ 1050 HWTEST_F(EventParserTest, GetTracePointParseErrorSubEventType, TestSize.Level1) 1051 { 1052 TS_LOGI("test5-48"); 1053 TracePoint point; 1054 std::string str("X|924|SuspendThreadByThreadId suspended Binder:924_8 id=39"); 1055 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1056 int32_t result = eventParser.printEventParser_.GetTracePoint(str, point); 1057 1058 EXPECT_TRUE(result == PARSE_ERROR); 1059 } 1060 1061 /** 1062 * @tc.name: GetThreadGroupId 1063 * @tc.desc: Test GetThreadGroupId interface 1064 * @tc.type: FUNC 1065 */ 1066 HWTEST_F(EventParserTest, GetThreadGroupId, TestSize.Level1) 1067 { 1068 TS_LOGI("test5-49"); 1069 size_t length{0}; 1070 std::string str("E|924"); 1071 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1072 int32_t result = eventParser.printEventParser_.GetThreadGroupId(str, length); 1073 1074 EXPECT_TRUE(result == 924); 1075 } 1076 1077 /** 1078 * @tc.name: GetThreadGroupIdParseErrorPid 1079 * @tc.desc: Test GetThreadGroupId interface parse error pid 1080 * @tc.type: FUNC 1081 */ 1082 HWTEST_F(EventParserTest, GetThreadGroupIdParseErrorPid, TestSize.Level1) 1083 { 1084 TS_LOGI("test5-50"); 1085 size_t length{0}; 1086 std::string str("E|abc"); 1087 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1088 int32_t result = eventParser.printEventParser_.GetThreadGroupId(str, length); 1089 1090 EXPECT_TRUE(result == PARSE_ERROR); 1091 } 1092 1093 /** 1094 * @tc.name: HandlerB 1095 * @tc.desc: Test HandlerB interface 1096 * @tc.type: FUNC 1097 */ 1098 HWTEST_F(EventParserTest, HandlerB, TestSize.Level1) 1099 { 1100 TS_LOGI("test5-51"); 1101 size_t length{3}; 1102 TracePoint outPoint; 1103 std::string str("B|924|HID::ISensors::batch::client"); 1104 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1105 int32_t result = eventParser.printEventParser_.HandlerB(str, outPoint, length); 1106 1107 EXPECT_TRUE(result == PARSE_SUCCESS); 1108 } 1109 1110 /** 1111 * @tc.name: HandlerBAbnormal 1112 * @tc.desc: Test HandlerBAbnormal interface using Abnormal format 1113 * @tc.type: FUNC 1114 */ 1115 HWTEST_F(EventParserTest, HandlerBAbnormal, TestSize.Level1) 1116 { 1117 TS_LOGI("test5-52"); 1118 size_t length{3}; 1119 TracePoint outPoint; 1120 std::string str("B|924|"); 1121 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1122 int32_t result = eventParser.printEventParser_.HandlerB(str, outPoint, length); 1123 1124 EXPECT_TRUE(result == PARSE_ERROR); 1125 } 1126 1127 /** 1128 * @tc.name: HandlerCsf 1129 * @tc.desc: Test HandlerCSF interface 1130 * @tc.type: FUNC 1131 */ 1132 HWTEST_F(EventParserTest, HandlerCsf, TestSize.Level1) 1133 { 1134 TS_LOGI("test5-53"); 1135 size_t length{4}; 1136 TracePoint outPoint; 1137 std::string str("C|2519|Heap size (KB)|2363"); 1138 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1139 int32_t result = eventParser.printEventParser_.HandlerCSF(str, outPoint, length); 1140 1141 EXPECT_TRUE(result == PARSE_SUCCESS); 1142 } 1143 1144 /** 1145 * @tc.name: HandlerCsfParseEmptyString 1146 * @tc.desc: Parse empty string using HandlerCSF interface 1147 * @tc.type: FUNC 1148 */ 1149 HWTEST_F(EventParserTest, HandlerCsfParseEmptyString, TestSize.Level1) 1150 { 1151 TS_LOGI("test5-54"); 1152 size_t length{4}; 1153 TracePoint outPoint; 1154 std::string str(""); 1155 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1156 int32_t result = eventParser.printEventParser_.HandlerCSF(str, outPoint, length); 1157 1158 EXPECT_TRUE(result == PARSE_ERROR); 1159 } 1160 1161 /** 1162 * @tc.name: HandlerCsfParseErrorFormate 1163 * @tc.desc: Parse "C|2519|Heap size (KB)|" using HandlerCSF interface 1164 * @tc.type: FUNC 1165 */ 1166 HWTEST_F(EventParserTest, HandlerCsfParseErrorFormate, TestSize.Level1) 1167 { 1168 TS_LOGI("test5-55"); 1169 size_t length{4}; 1170 TracePoint outPoint; 1171 std::string str("C|2519|Heap size (KB)|"); 1172 BytraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1173 int32_t result = eventParser.printEventParser_.HandlerCSF(str, outPoint, length); 1174 1175 EXPECT_TRUE(result == PARSE_ERROR); 1176 } 1177 } // namespace TraceStreamer 1178 } // namespace SysTuning 1179