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