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