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