1 /* 2 * Copyright (c) 2021 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <hwext/gtest-ext.h> 17 #include <hwext/gtest-tag.h> 18 19 #include "htrace_cpu_detail_parser.h" 20 #include "htrace_event_parser.h" 21 #include "irq_filter.h" 22 #include "trace_streamer_selector.h" 23 #include "ts_common.h" 24 #include "types/plugins/ftrace_data/trace_plugin_result.pb.h" 25 26 using namespace testing::ext; 27 using namespace SysTuning::TraceStreamer; 28 namespace SysTuning { 29 namespace TraceStreamer { 30 class HtraceIrqEventTest : public ::testing::Test { 31 public: SetUp()32 void SetUp() 33 { 34 stream_.InitFilter();} 35 TearDown()36 void TearDown() {} 37 38 public: 39 SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {}; 40 }; 41 42 /** 43 * @tc.name: IrqHandlerEntryTest 44 * @tc.desc: Binary formate IrqHandlerEntry Normal TEST 45 * @tc.type: FUNC 46 */ 47 HWTEST_F(HtraceIrqEventTest, IrqHandlerEntryTest, TestSize.Level1) 48 { 49 TS_LOGI("test10-1"); 50 int64_t ts1 = 100; 51 uint32_t cpu1 = 1; 52 std::string appName = "app1"; 53 uint32_t tid1 = 1; 54 int32_t irq = 12; 55 IrqHandlerEntryFormat* irqHandlerEvent = new IrqHandlerEntryFormat(); 56 irqHandlerEvent->set_irq(irq); 57 irqHandlerEvent->set_name("user_irq"); 58 FtraceCpuDetailMsg ftraceCpuDetail; 59 ftraceCpuDetail.set_cpu(cpu1); 60 ftraceCpuDetail.set_overwrite(0); 61 auto ftraceEvent = ftraceCpuDetail.add_event(); 62 63 ftraceEvent->set_timestamp(ts1); 64 ftraceEvent->set_tgid(tid1); 65 ftraceEvent->set_comm(appName); 66 ftraceEvent->set_allocated_irq_handler_entry_format(irqHandlerEvent); 67 68 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 69 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 70 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 71 } 72 73 /** 74 * @tc.name: IrqHandlerEntryTestNotMatch 75 * @tc.desc: Binary formate IrqHandlerEntry, only start, no end 76 * @tc.type: FUNC 77 */ 78 HWTEST_F(HtraceIrqEventTest, IrqHandlerEntryTestNotMatch, TestSize.Level1) 79 { 80 TS_LOGI("test10-2"); 81 int64_t ts1 = 120; 82 uint32_t cpu1 = 1; 83 std::string appName = "app1"; 84 uint32_t tid1 = 1; 85 int32_t irq = 12; 86 IrqHandlerEntryFormat* irqHandlerEvent = new IrqHandlerEntryFormat(); 87 irqHandlerEvent->set_irq(irq); 88 irqHandlerEvent->set_name("user_irq"); 89 FtraceCpuDetailMsg ftraceCpuDetail; 90 ftraceCpuDetail.set_cpu(cpu1); 91 ftraceCpuDetail.set_overwrite(0); 92 auto ftraceEvent = ftraceCpuDetail.add_event(); 93 94 ftraceEvent->set_timestamp(ts1); 95 ftraceEvent->set_tgid(tid1); 96 ftraceEvent->set_comm(appName); 97 ftraceEvent->set_allocated_irq_handler_entry_format(irqHandlerEvent); 98 99 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 100 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 101 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 102 ts1 = 110; 103 IrqHandlerEntryFormat* irqHandlerEvent2 = new IrqHandlerEntryFormat(); 104 irqHandlerEvent2->set_irq(irq); 105 irqHandlerEvent2->set_name("user_irq"); 106 FtraceCpuDetailMsg ftraceCpuDetail2; 107 ftraceCpuDetail2.set_cpu(cpu1); 108 ftraceCpuDetail2.set_overwrite(0); 109 auto ftraceEvent2 = ftraceCpuDetail2.add_event(); 110 111 ftraceEvent2->set_timestamp(ts1); 112 ftraceEvent2->set_tgid(tid1); 113 ftraceEvent2->set_comm(appName); 114 ftraceEvent2->set_allocated_irq_handler_entry_format(irqHandlerEvent2); 115 eventParser.ParseDataItem(&ftraceCpuDetail2, TS_CLOCK_BOOTTIME); 116 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 2); 117 118 auto eventCount = 119 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_IRQ_HANDLER_ENTRY, STAT_EVENT_DATA_LOST); 120 EXPECT_TRUE(1 == eventCount); 121 } 122 123 /** 124 * @tc.name: IrqHandlerExitTestEmpty 125 * @tc.desc: Binary formate IrqHandlerExit, Interrupt only ends, not starts 126 * @tc.type: FUNC 127 */ 128 HWTEST_F(HtraceIrqEventTest, IrqHandlerExitTestEmpty, TestSize.Level1) 129 { 130 TS_LOGI("test10-3"); 131 int64_t ts1 = 100; 132 uint32_t cpu1 = 1; 133 uint32_t ret = 1; 134 std::string appName = "app1"; 135 uint32_t tid1 = 1; 136 int32_t irq = 12; // 1 for handled, else for unhandled 137 138 IrqHandlerExitFormat* irqHandlerExitEvent = new IrqHandlerExitFormat(); 139 irqHandlerExitEvent->set_irq(irq); 140 irqHandlerExitEvent->set_ret(ret); 141 FtraceCpuDetailMsg ftraceCpuDetail; 142 ftraceCpuDetail.set_cpu(cpu1); 143 ftraceCpuDetail.set_overwrite(0); 144 auto ftraceEvent = ftraceCpuDetail.add_event(); 145 146 ftraceEvent->set_timestamp(ts1); 147 ftraceEvent->set_tgid(tid1); 148 ftraceEvent->set_comm(appName); 149 ftraceEvent->set_allocated_irq_handler_exit_format(irqHandlerExitEvent); 150 151 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 152 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 153 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 0); 154 auto eventCount = 155 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_IRQ_HANDLER_EXIT, STAT_EVENT_NOTMATCH); 156 EXPECT_TRUE(1 == eventCount); 157 } 158 159 /** 160 * @tc.name: IrqHandlerEnterAndExitTest 161 * @tc.desc: Binary formate IrqHandlerEnter, Interrupt normal start and end 162 * @tc.type: FUNC 163 */ 164 HWTEST_F(HtraceIrqEventTest, IrqHandlerEnterAndExitTest, TestSize.Level1) 165 { 166 TS_LOGI("test10-4"); 167 int64_t ts1 = 100; 168 uint32_t cpu1 = 1; 169 std::string appName = "app1"; 170 uint32_t tid1 = 1; 171 int32_t irq = 12; 172 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 173 174 IrqHandlerEntryFormat* irqHandlerEvent = new IrqHandlerEntryFormat(); 175 irqHandlerEvent->set_irq(irq); 176 irqHandlerEvent->set_name("user_irq"); 177 FtraceCpuDetailMsg ftraceCpuDetail; 178 ftraceCpuDetail.set_cpu(cpu1); 179 ftraceCpuDetail.set_overwrite(0); 180 auto ftraceEvent = ftraceCpuDetail.add_event(); 181 182 ftraceEvent->set_timestamp(ts1); 183 ftraceEvent->set_tgid(tid1); 184 ftraceEvent->set_comm(appName); 185 ftraceEvent->set_allocated_irq_handler_entry_format(irqHandlerEvent); 186 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 187 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 188 uint32_t ret = 1; // 1 for handled, else for unhandled 189 190 IrqHandlerExitFormat* irqHandlerExitEvent = new IrqHandlerExitFormat(); 191 irqHandlerExitEvent->set_irq(irq); 192 irqHandlerExitEvent->set_ret(ret); 193 FtraceCpuDetailMsg ftraceCpuDetail2; 194 ftraceCpuDetail2.set_cpu(cpu1); 195 ftraceCpuDetail2.set_overwrite(0); 196 auto ftraceEvent2 = ftraceCpuDetail2.add_event(); 197 198 ftraceEvent2->set_timestamp(ts1); 199 ftraceEvent2->set_tgid(tid1); 200 ftraceEvent2->set_comm(appName); 201 ftraceEvent2->set_allocated_irq_handler_exit_format(irqHandlerExitEvent); 202 203 eventParser.ParseDataItem(&ftraceCpuDetail2, TS_CLOCK_BOOTTIME); 204 205 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 206 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0); 207 } 208 209 /** 210 * @tc.name: IrqHandlerEnterAndExitTestTwice 211 * @tc.desc: Binary formate IrqHandlerEnter and Exit, Interrupt normal start and end Twice 212 * @tc.type: FUNC 213 */ 214 HWTEST_F(HtraceIrqEventTest, IrqHandlerEnterAndExitTestTwice, TestSize.Level1) 215 { 216 TS_LOGI("test10-4-2"); 217 int64_t ts1 = 100; 218 uint32_t cpu1 = 1; 219 std::string appName = "app1"; 220 uint32_t tid1 = 1; 221 int32_t irq = 12; 222 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 223 224 IrqHandlerEntryFormat* irqHandlerEvent = new IrqHandlerEntryFormat(); 225 irqHandlerEvent->set_irq(irq); 226 irqHandlerEvent->set_name("user_irq"); 227 FtraceCpuDetailMsg ftraceCpuDetail; 228 ftraceCpuDetail.set_cpu(cpu1); 229 ftraceCpuDetail.set_overwrite(0); 230 auto ftraceEvent = ftraceCpuDetail.add_event(); 231 232 ftraceEvent->set_timestamp(ts1); 233 ftraceEvent->set_tgid(tid1); 234 ftraceEvent->set_comm(appName); 235 ftraceEvent->set_allocated_irq_handler_entry_format(irqHandlerEvent); 236 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 237 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 238 uint32_t ret = 1; // 1 for handled, else for unhandled 239 cpu1 = 2; 240 ts1 = 150; 241 242 IrqHandlerExitFormat* irqHandlerExitEvent = new IrqHandlerExitFormat(); 243 irqHandlerExitEvent->set_irq(irq); 244 irqHandlerExitEvent->set_ret(ret); 245 FtraceCpuDetailMsg ftraceCpuDetail2; 246 ftraceCpuDetail2.set_cpu(cpu1); 247 ftraceCpuDetail2.set_overwrite(0); 248 auto ftraceEvent2 = ftraceCpuDetail2.add_event(); 249 250 ftraceEvent2->set_timestamp(ts1); 251 ftraceEvent2->set_tgid(tid1); 252 ftraceEvent2->set_comm(appName); 253 ftraceEvent2->set_allocated_irq_handler_exit_format(irqHandlerExitEvent); 254 255 eventParser.ParseDataItem(&ftraceCpuDetail2, TS_CLOCK_BOOTTIME); 256 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 257 EXPECT_TRUE(stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_IRQ_HANDLER_EXIT, 258 STAT_EVENT_NOTMATCH) == 1); 259 cpu1 = 1; 260 ts1 = 200; 261 262 IrqHandlerExitFormat* irqHandlerExitEvent2 = new IrqHandlerExitFormat(); 263 irqHandlerExitEvent2->set_irq(irq); 264 irqHandlerExitEvent2->set_ret(ret); 265 FtraceCpuDetailMsg ftraceCpuDetail3; 266 ftraceCpuDetail3.set_cpu(cpu1); 267 ftraceCpuDetail3.set_overwrite(0); 268 auto ftraceEvent3 = ftraceCpuDetail3.add_event(); 269 270 ftraceEvent3->set_timestamp(ts1); 271 ftraceEvent3->set_tgid(tid1); 272 ftraceEvent3->set_comm(appName); 273 ftraceEvent3->set_allocated_irq_handler_exit_format(irqHandlerExitEvent2); 274 275 eventParser.ParseDataItem(&ftraceCpuDetail3, TS_CLOCK_BOOTTIME); 276 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 277 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0); 278 } 279 280 /** 281 * @tc.name: SoftIrqEntryTest 282 * @tc.desc: Binary format Soft interrupt normal test 283 * @tc.type: FUNC 284 */ 285 HWTEST_F(HtraceIrqEventTest, SoftIrqEntryTest, TestSize.Level1) 286 { 287 TS_LOGI("test10-6"); 288 int64_t ts1 = 100; 289 uint32_t cpu1 = 1; 290 uint32_t vec = 1; 291 std::string appName = "app1"; 292 uint32_t tid1 = 1; 293 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 294 295 SoftirqEntryFormat* softirqEntryEvent = new SoftirqEntryFormat(); 296 softirqEntryEvent->set_vec(vec); 297 FtraceCpuDetailMsg ftraceCpuDetail; 298 ftraceCpuDetail.set_cpu(cpu1); 299 ftraceCpuDetail.set_overwrite(0); 300 auto ftraceEvent = ftraceCpuDetail.add_event(); 301 302 ftraceEvent->set_timestamp(ts1); 303 ftraceEvent->set_tgid(tid1); 304 ftraceEvent->set_comm(appName); 305 ftraceEvent->set_allocated_softirq_entry_format(softirqEntryEvent); 306 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 307 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 308 } 309 310 /** 311 * @tc.name: SoftIrqEntryNotMatch 312 * @tc.desc: The binary format soft interrupts do not match. The two interrupts have only the beginning and no end 313 * @tc.type: FUNC 314 */ 315 HWTEST_F(HtraceIrqEventTest, SoftIrqEntryNotMatch, TestSize.Level1) 316 { 317 TS_LOGI("test10-7"); 318 int64_t ts1 = 100; 319 uint32_t cpu1 = 1; 320 uint32_t vec = 1; 321 std::string appName = "app1"; 322 uint32_t tid1 = 1; 323 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 324 325 SoftirqEntryFormat* softirqEntryEvent = new SoftirqEntryFormat(); 326 softirqEntryEvent->set_vec(vec); 327 FtraceCpuDetailMsg ftraceCpuDetail; 328 ftraceCpuDetail.set_cpu(cpu1); 329 ftraceCpuDetail.set_overwrite(0); 330 auto ftraceEvent = ftraceCpuDetail.add_event(); 331 332 ftraceEvent->set_timestamp(ts1); 333 ftraceEvent->set_tgid(tid1); 334 ftraceEvent->set_comm(appName); 335 ftraceEvent->set_allocated_softirq_entry_format(softirqEntryEvent); 336 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 337 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 338 ts1 = 150; 339 340 SoftirqEntryFormat* softirqEntryEvent2 = new SoftirqEntryFormat(); 341 softirqEntryEvent2->set_vec(vec); 342 FtraceCpuDetailMsg ftraceCpuDetail2; 343 ftraceCpuDetail2.set_cpu(cpu1); 344 ftraceCpuDetail2.set_overwrite(0); 345 auto ftraceEvent2 = ftraceCpuDetail2.add_event(); 346 347 ftraceEvent2->set_timestamp(ts1); 348 ftraceEvent2->set_tgid(tid1); 349 ftraceEvent2->set_comm(appName); 350 ftraceEvent2->set_allocated_softirq_entry_format(softirqEntryEvent2); 351 eventParser.ParseDataItem(&ftraceCpuDetail2, TS_CLOCK_BOOTTIME); 352 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 2); 353 EXPECT_TRUE( 354 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_SOFTIRQ_ENTRY, STAT_EVENT_DATA_LOST) == 1); 355 } 356 357 /** 358 * @tc.name: SoftIrqExitEmptyTest 359 * @tc.desc: The binary format soft interrupt only ends without starting 360 * @tc.type: FUNC 361 */ 362 HWTEST_F(HtraceIrqEventTest, SoftIrqExitEmptyTest, TestSize.Level1) 363 { 364 TS_LOGI("test10-8"); 365 int64_t ts1 = 100; 366 uint32_t cpu1 = 1; 367 uint32_t vec = 1; 368 std::string appName = "app1"; 369 uint32_t tid1 = 1; 370 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 371 372 SoftirqExitFormat* softirqExitEvent = new SoftirqExitFormat(); 373 softirqExitEvent->set_vec(vec); 374 FtraceCpuDetailMsg ftraceCpuDetail; 375 ftraceCpuDetail.set_cpu(cpu1); 376 ftraceCpuDetail.set_overwrite(0); 377 auto ftraceEvent = ftraceCpuDetail.add_event(); 378 379 ftraceEvent->set_timestamp(ts1); 380 ftraceEvent->set_tgid(tid1); 381 ftraceEvent->set_comm(appName); 382 ftraceEvent->set_allocated_softirq_exit_format(softirqExitEvent); 383 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 384 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 0); 385 EXPECT_TRUE( 386 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_DATA_LOST) == 1); 387 } 388 389 /** 390 * @tc.name: SoftIrqTest 391 * @tc.desc: The binary format soft interrupt normal test 392 * @tc.type: FUNC 393 */ 394 HWTEST_F(HtraceIrqEventTest, SoftIrqTest, TestSize.Level1) 395 { 396 TS_LOGI("test10-9"); 397 int64_t ts1 = 100; 398 uint32_t cpu1 = 1; 399 uint32_t vec = 1; 400 std::string appName = "app1"; 401 uint32_t tid1 = 1; 402 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 403 404 SoftirqEntryFormat* softirqEntryEvent = new SoftirqEntryFormat(); 405 softirqEntryEvent->set_vec(vec); 406 FtraceCpuDetailMsg ftraceCpuDetail; 407 ftraceCpuDetail.set_cpu(cpu1); 408 ftraceCpuDetail.set_overwrite(0); 409 auto ftraceEvent = ftraceCpuDetail.add_event(); 410 411 ftraceEvent->set_timestamp(ts1); 412 ftraceEvent->set_tgid(tid1); 413 ftraceEvent->set_comm(appName); 414 ftraceEvent->set_allocated_softirq_entry_format(softirqEntryEvent); 415 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 416 417 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 418 ts1 = 150; 419 SoftirqExitFormat* softirqExitEvent = new SoftirqExitFormat(); 420 softirqExitEvent->set_vec(vec); 421 FtraceCpuDetailMsg ftraceCpuDetail2; 422 ftraceCpuDetail2.set_cpu(cpu1); 423 ftraceCpuDetail2.set_overwrite(0); 424 auto ftraceEvent2 = ftraceCpuDetail2.add_event(); 425 426 ftraceEvent2->set_timestamp(ts1); 427 ftraceEvent2->set_tgid(tid1); 428 ftraceEvent2->set_comm(appName); 429 ftraceEvent2->set_allocated_softirq_exit_format(softirqExitEvent); 430 eventParser.ParseDataItem(&ftraceCpuDetail2, TS_CLOCK_BOOTTIME); 431 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 432 } 433 434 /** 435 * @tc.name: SoftIrqTestNotMatch 436 * @tc.desc: The binary soft interrupt test not match 437 * @tc.type: FUNC 438 */ 439 HWTEST_F(HtraceIrqEventTest, SoftIrqTestNotMatch, TestSize.Level1) 440 { 441 TS_LOGI("test10-10"); 442 int64_t ts1 = 100; 443 uint32_t cpu1 = 1; 444 uint32_t vec = 1; 445 std::string appName = "app1"; 446 uint32_t tid1 = 1; 447 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 448 449 SoftirqEntryFormat* softirqEntryEvent = new SoftirqEntryFormat(); 450 softirqEntryEvent->set_vec(vec); 451 FtraceCpuDetailMsg ftraceCpuDetail; 452 ftraceCpuDetail.set_cpu(cpu1); 453 ftraceCpuDetail.set_overwrite(0); 454 auto ftraceEvent = ftraceCpuDetail.add_event(); 455 456 ftraceEvent->set_timestamp(ts1); 457 ftraceEvent->set_tgid(tid1); 458 ftraceEvent->set_comm(appName); 459 ftraceEvent->set_allocated_softirq_entry_format(softirqEntryEvent); 460 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 461 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 462 ts1 = 150; 463 cpu1 = 2; 464 465 SoftirqExitFormat* softirqExitEvent = new SoftirqExitFormat(); 466 softirqExitEvent->set_vec(vec); 467 FtraceCpuDetailMsg ftraceCpuDetail2; 468 ftraceCpuDetail2.set_cpu(cpu1); 469 ftraceCpuDetail2.set_overwrite(0); 470 auto ftraceEvent2 = ftraceCpuDetail2.add_event(); 471 472 ftraceEvent2->set_timestamp(ts1); 473 ftraceEvent2->set_tgid(tid1); 474 ftraceEvent2->set_comm(appName); 475 ftraceEvent2->set_allocated_softirq_exit_format(softirqExitEvent); 476 eventParser.ParseDataItem(&ftraceCpuDetail2, TS_CLOCK_BOOTTIME); 477 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 478 EXPECT_TRUE(stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_DATA_LOST) == 1); 479 } 480 } // namespace TraceStreamer 481 } // namespace SysTuning 482