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