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