• 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 <fcntl.h>
17 #include <hwext/gtest-ext.h>
18 #include <hwext/gtest-tag.h>
19 #include <unordered_map>
20 
21 #include "cpu_filter.h"
22 #include "htrace_cpu_detail_parser.h"
23 #include "parser/common_types.h"
24 #include "trace_streamer_filters.h"
25 #include "trace_streamer_selector.h"
26 
27 using namespace testing::ext;
28 using namespace SysTuning::TraceStreamer;
29 namespace SysTuning {
30 namespace TraceStreamer {
31 const uint64_t TIMESTAMP = 1616439852302;
32 const std::string THREAD_NAME_01 = "ACCS0";
33 const std::string THREAD_NAME_02 = "HeapTaskDaemon";
34 const uint32_t PRIORITY_01 = 120;
35 const uint32_t PRIORITY_02 = 124;
36 const uint32_t PID_01 = 2716;
37 const uint32_t PID_02 = 2532;
38 class HtraceEventParserTest : public ::testing::Test {
39 public:
SetUp()40     void SetUp()
41     {
42         stream_.InitFilter();
43     }
44 
TearDown()45     void TearDown() {}
46 
47 public:
48     SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {};
49 };
50 
51 /**
52  * @tc.name: ParseSchedSwitchEvent
53  * @tc.desc: Parse a schedswitch event in htrace format
54  * @tc.type: FUNC
55  */
56 HWTEST_F(HtraceEventParserTest, ParseSchedSwitchEvent, TestSize.Level1)
57 {
58     SchedSwitchFormat* event = new SchedSwitchFormat();
59     event->set_prev_prio(PRIORITY_01);
60     event->set_next_prio(PRIORITY_02);
61     event->set_prev_pid(PID_01);
62     event->set_next_pid(PID_02);
63     event->set_prev_comm(THREAD_NAME_01);
64     event->set_next_comm(THREAD_NAME_02);
65     event->set_prev_state(1);
66 
67     FtraceCpuDetailMsg ftraceCpuDetail;
68     ftraceCpuDetail.set_cpu(0);
69     ftraceCpuDetail.set_overwrite(0);
70     auto ftraceEvent = ftraceCpuDetail.add_event();
71 
72     ftraceEvent->set_timestamp(TIMESTAMP);
73     ftraceEvent->set_tgid(1);
74     ftraceEvent->set_comm(THREAD_NAME_02);
75     ftraceEvent->unsafe_arena_set_allocated_sched_switch_format(event);
76 
77     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
78     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
79     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
80     EXPECT_TRUE(1);
81     auto realTimeStamp = stream_.traceDataCache_->GetConstSchedSliceData().TimeStamData()[0];
82     EXPECT_TRUE(TIMESTAMP == realTimeStamp);
83     auto realCpu = stream_.traceDataCache_->GetConstSchedSliceData().CpusData()[0];
84     EXPECT_TRUE(0 == realCpu);
85 }
86 
87 /**
88  * @tc.name: ParseFtraceCpuDetailMsgHasNoEvent
89  * @tc.desc: FtraceCpuDetailMsg has no ftrace event
90  * @tc.type: FUNC
91  */
92 HWTEST_F(HtraceEventParserTest, ParseFtraceCpuDetailMsgHasNoEvent, TestSize.Level1)
93 {
94     FtraceCpuDetailMsg ftraceCpuDetail;
95     ftraceCpuDetail.set_cpu(0);
96     ftraceCpuDetail.set_overwrite(0);
97 
98     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
99     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
100     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
101 
102     auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_OTHER, STAT_EVENT_DATA_LOST);
103     EXPECT_TRUE(0 == eventCount);
104 }
105 
106 /**
107  * @tc.name: ParseFtraceCpuDetailMsgOverwriteTrue
108  * @tc.desc: FtraceCpuDetailMsg overwrit is true
109  * @tc.type: FUNC
110  */
111 HWTEST_F(HtraceEventParserTest, ParseFtraceCpuDetailMsgOverwriteTrue, TestSize.Level1)
112 {
113     SchedSwitchFormat* event = new SchedSwitchFormat();
114     event->set_prev_prio(PRIORITY_01);
115     event->set_next_prio(PRIORITY_02);
116     event->set_prev_pid(PID_01);
117     event->set_next_pid(PID_02);
118     event->set_prev_comm(THREAD_NAME_01);
119     event->set_next_comm(THREAD_NAME_02);
120     event->set_prev_state(1);
121 
122     FtraceCpuDetailMsg ftraceCpuDetail;
123     ftraceCpuDetail.set_cpu(0);
124     ftraceCpuDetail.set_overwrite(1);
125     auto ftraceEvent = ftraceCpuDetail.add_event();
126 
127     ftraceEvent->set_timestamp(TIMESTAMP);
128     ftraceEvent->set_tgid(1);
129     ftraceEvent->set_comm(THREAD_NAME_02);
130     ftraceEvent->set_allocated_sched_switch_format(event);
131 
132     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
133     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
134     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
135     auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_OTHER, STAT_EVENT_DATA_LOST);
136     EXPECT_TRUE(1 == eventCount);
137 }
138 
139 /**
140  * @tc.name: ParseTaskRenameEvent
141  * @tc.desc: Parse a task_rename event in htrace format
142  * @tc.type: FUNC
143  */
144 HWTEST_F(HtraceEventParserTest, ParseTaskRenameEvent, TestSize.Level1)
145 {
146     TaskRenameFormat* taskRenameEvent = new TaskRenameFormat();
147     taskRenameEvent->set_pid(PID_01);
148     taskRenameEvent->set_oldcomm(THREAD_NAME_01);
149     taskRenameEvent->set_newcomm(THREAD_NAME_02);
150     taskRenameEvent->set_oom_score_adj(1);
151 
152     FtraceCpuDetailMsg ftraceCpuDetail;
153     ftraceCpuDetail.set_cpu(0);
154     ftraceCpuDetail.set_overwrite(0);
155     auto ftraceEvent = ftraceCpuDetail.add_event();
156 
157     ftraceEvent->set_timestamp(TIMESTAMP);
158     ftraceEvent->set_tgid(1);
159     ftraceEvent->set_comm(THREAD_NAME_02);
160     ftraceEvent->set_allocated_task_rename_format(taskRenameEvent);
161 
162     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
163     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
164     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
165     auto eventCount =
166         stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_TASK_RENAME, STAT_EVENT_RECEIVED);
167     EXPECT_TRUE(1 == eventCount);
168 }
169 
170 /**
171  * @tc.name: ParseTaskNewtaskEvent
172  * @tc.desc: Parse a task_newtask event in htrace format
173  * @tc.type: FUNC
174  */
175 HWTEST_F(HtraceEventParserTest, ParseTaskNewtaskEvent, TestSize.Level1)
176 {
177     TaskNewtaskFormat* newTaskEvent = new TaskNewtaskFormat();
178     newTaskEvent->set_pid(PID_01);
179     newTaskEvent->set_comm(THREAD_NAME_01);
180     newTaskEvent->set_clone_flags(0);
181     newTaskEvent->set_oom_score_adj(1);
182 
183     FtraceCpuDetailMsg ftraceCpuDetail;
184     ftraceCpuDetail.set_cpu(0);
185     ftraceCpuDetail.set_overwrite(0);
186     auto ftraceEvent = ftraceCpuDetail.add_event();
187 
188     ftraceEvent->set_timestamp(TIMESTAMP);
189     ftraceEvent->set_tgid(1);
190     ftraceEvent->set_comm(THREAD_NAME_02);
191     ftraceEvent->set_allocated_task_newtask_format(newTaskEvent);
192 
193     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
194     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
195     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
196     auto eventCount =
197         stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_TASK_NEWTASK, STAT_EVENT_RECEIVED);
198     EXPECT_TRUE(1 == eventCount);
199 }
200 
201 /**
202  * @tc.name: ParseSchedWakeupEvent
203  * @tc.desc: Parse a sched_wakeup event in htrace format
204  * @tc.type: FUNC
205  */
206 HWTEST_F(HtraceEventParserTest, ParseSchedWakeupEvent, TestSize.Level1)
207 {
208     SchedWakeupFormat* wakeupEvent = new SchedWakeupFormat();
209     wakeupEvent->set_comm(THREAD_NAME_01);
210     wakeupEvent->set_pid(PRIORITY_02);
211     wakeupEvent->set_prio(PID_01);
212     wakeupEvent->set_target_cpu(1);
213 
214     FtraceCpuDetailMsg ftraceCpuDetail;
215     ftraceCpuDetail.set_cpu(0);
216     ftraceCpuDetail.set_overwrite(0);
217     auto ftraceEvent = ftraceCpuDetail.add_event();
218 
219     ftraceEvent->set_timestamp(TIMESTAMP);
220     ftraceEvent->set_tgid(1);
221     ftraceEvent->set_comm(THREAD_NAME_02);
222     ftraceEvent->set_allocated_sched_wakeup_format(wakeupEvent);
223 
224     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
225     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
226     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
227     auto eventCount =
228         stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_SCHED_WAKEUP, STAT_EVENT_RECEIVED);
229     EXPECT_TRUE(1 == eventCount);
230 }
231 
232 /**
233  * @tc.name: ParseSchedWakingEvent
234  * @tc.desc: Parse a sched_waking event in htrace format
235  * @tc.type: FUNC
236  */
237 HWTEST_F(HtraceEventParserTest, ParseSchedWakingEvent, TestSize.Level1)
238 {
239     SchedWakingFormat* wakingEvent = new SchedWakingFormat();
240     wakingEvent->set_comm(THREAD_NAME_01);
241     wakingEvent->set_pid(PRIORITY_02);
242     wakingEvent->set_prio(PID_01);
243     wakingEvent->set_target_cpu(1);
244 
245     FtraceCpuDetailMsg ftraceCpuDetail;
246     ftraceCpuDetail.set_cpu(0);
247     ftraceCpuDetail.set_overwrite(0);
248     auto ftraceEvent = ftraceCpuDetail.add_event();
249 
250     ftraceEvent->set_timestamp(TIMESTAMP);
251     ftraceEvent->set_tgid(1);
252     ftraceEvent->set_comm(THREAD_NAME_02);
253     ftraceEvent->set_allocated_sched_waking_format(wakingEvent);
254 
255     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
256     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
257     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
258     auto eventCount =
259         stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_SCHED_WAKING, STAT_EVENT_RECEIVED);
260     EXPECT_TRUE(1 == eventCount);
261 }
262 
263 /**
264  * @tc.name: ParseCpuIdleEvent
265  * @tc.desc: Parse a cpuIdle event in htrace format
266  * @tc.type: FUNC
267  */
268 HWTEST_F(HtraceEventParserTest, ParseCpuIdleEvent, TestSize.Level1)
269 {
270     CpuIdleFormat* cpuIdleEvent = new CpuIdleFormat();
271     cpuIdleEvent->set_cpu_id(0);
272     cpuIdleEvent->set_state(1);
273 
274     FtraceCpuDetailMsg ftraceCpuDetail;
275     ftraceCpuDetail.set_cpu(0);
276     ftraceCpuDetail.set_overwrite(0);
277     auto ftraceEvent = ftraceCpuDetail.add_event();
278 
279     ftraceEvent->set_timestamp(TIMESTAMP);
280     ftraceEvent->set_tgid(1);
281     ftraceEvent->set_comm(THREAD_NAME_02);
282     ftraceEvent->set_allocated_cpu_idle_format(cpuIdleEvent);
283 
284     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
285     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
286     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
287     auto eventCount =
288         stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CPU_IDLE, STAT_EVENT_RECEIVED);
289     EXPECT_TRUE(1 == eventCount);
290 }
291 
292 /**
293  * @tc.name: ParseCpuFrequencyEvent
294  * @tc.desc: Parse a CpuFrequency event in htrace format
295  * @tc.type: FUNC
296  */
297 HWTEST_F(HtraceEventParserTest, ParseCpuFrequencyEvent, TestSize.Level1)
298 {
299     CpuFrequencyFormat* cpuFrequencyEvent = new CpuFrequencyFormat();
300     cpuFrequencyEvent->set_cpu_id(0);
301     cpuFrequencyEvent->set_state(1);
302 
303     FtraceCpuDetailMsg ftraceCpuDetail;
304     ftraceCpuDetail.set_cpu(0);
305     ftraceCpuDetail.set_overwrite(0);
306     auto ftraceEvent = ftraceCpuDetail.add_event();
307 
308     ftraceEvent->set_timestamp(TIMESTAMP);
309     ftraceEvent->set_tgid(2);
310     ftraceEvent->set_comm(THREAD_NAME_02);
311     ftraceEvent->set_allocated_cpu_frequency_format(cpuFrequencyEvent);
312 
313     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
314     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
315     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
316     auto eventCount =
317         stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_RECEIVED);
318     EXPECT_TRUE(1 == eventCount);
319 }
320 
321 /**
322  * @tc.name: ParseWorkqueueExecuteStartEvent
323  * @tc.desc: Parse a WorkqueueExecuteStart event in htrace format
324  * @tc.type: FUNC
325  */
326 HWTEST_F(HtraceEventParserTest, ParseWorkqueueExecuteStartEvent, TestSize.Level1)
327 {
328     WorkqueueExecuteStartFormat* workqueueExecuteStartEvent = new WorkqueueExecuteStartFormat();
329     workqueueExecuteStartEvent->set_work(0);
330     workqueueExecuteStartEvent->set_function(1);
331 
332     FtraceCpuDetailMsg ftraceCpuDetail;
333     ftraceCpuDetail.set_cpu(0);
334     ftraceCpuDetail.set_overwrite(0);
335     auto ftraceEvent = ftraceCpuDetail.add_event();
336 
337     ftraceEvent->set_timestamp(TIMESTAMP);
338     ftraceEvent->set_tgid(1);
339     ftraceEvent->set_comm(THREAD_NAME_02);
340     ftraceEvent->set_allocated_workqueue_execute_start_format(workqueueExecuteStartEvent);
341 
342     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
343     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
344     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
345     auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_WORKQUEUE_EXECUTE_START,
346                                                                               STAT_EVENT_RECEIVED);
347     EXPECT_TRUE(1 == eventCount);
348 }
349 
350 /**
351  * @tc.name: ParseWorkqueueExecuteEndEvent
352  * @tc.desc: Parse a WorkqueueExecuteEnd event in htrace format
353  * @tc.type: FUNC
354  */
355 HWTEST_F(HtraceEventParserTest, ParseWorkqueueExecuteEndEvent, TestSize.Level1)
356 {
357     WorkqueueExecuteEndFormat* workqueueExecuteEndEvent = new WorkqueueExecuteEndFormat();
358     workqueueExecuteEndEvent->set_work(0);
359 
360     FtraceCpuDetailMsg ftraceCpuDetail;
361     ftraceCpuDetail.set_cpu(0);
362     ftraceCpuDetail.set_overwrite(0);
363     auto ftraceEvent = ftraceCpuDetail.add_event();
364 
365     ftraceEvent->set_timestamp(TIMESTAMP);
366     ftraceEvent->set_tgid(1);
367     ftraceEvent->set_comm(THREAD_NAME_02);
368     ftraceEvent->set_allocated_workqueue_execute_end_format(workqueueExecuteEndEvent);
369 
370     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
371     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
372     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
373     auto eventCount =
374         stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_WORKQUEUE_EXECUTE_END, STAT_EVENT_RECEIVED);
375     EXPECT_TRUE(1 == eventCount);
376 }
377 
378 /**
379  * @tc.name: ParseClockDisableEvent
380  * @tc.desc: Parse a clock_Disable event in htrace format
381  * @tc.type: FUNC
382  */
383 HWTEST_F(HtraceEventParserTest, ParseClockDisableEvent, TestSize.Level1)
384 {
385     ClockDisableFormat* clockDisableEvent = new ClockDisableFormat();
386     clockDisableEvent->set_name(THREAD_NAME_02);
387     clockDisableEvent->set_cpu_id(0);
388     clockDisableEvent->set_state(1);
389 
390     FtraceCpuDetailMsg ftraceCpuDetail;
391     ftraceCpuDetail.set_cpu(0);
392     ftraceCpuDetail.set_overwrite(0);
393     auto ftraceEvent = ftraceCpuDetail.add_event();
394 
395     ftraceEvent->set_timestamp(TIMESTAMP);
396     ftraceEvent->set_tgid(2);
397     ftraceEvent->set_comm(THREAD_NAME_02);
398     ftraceEvent->set_allocated_clock_disable_format(clockDisableEvent);
399 
400     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
401     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
402     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
403     auto eventCount =
404         stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLOCK_DISABLE, STAT_EVENT_RECEIVED);
405     EXPECT_TRUE(1 == eventCount);
406 }
407 
408 /**
409  * @tc.name: ParseClockEnableEvent
410  * @tc.desc: Parse a clock_Enable event in htrace format
411  * @tc.type: FUNC
412  */
413 HWTEST_F(HtraceEventParserTest, ParseClockEnableEvent, TestSize.Level1)
414 {
415     ClockEnableFormat* clockEnableEvent = new ClockEnableFormat();
416     clockEnableEvent->set_name(THREAD_NAME_02);
417     clockEnableEvent->set_cpu_id(0);
418     clockEnableEvent->set_state(1);
419 
420     FtraceCpuDetailMsg ftraceCpuDetail;
421     ftraceCpuDetail.set_cpu(0);
422     ftraceCpuDetail.set_overwrite(0);
423     auto ftraceEvent = ftraceCpuDetail.add_event();
424 
425     ftraceEvent->set_timestamp(TIMESTAMP);
426     ftraceEvent->set_tgid(2);
427     ftraceEvent->set_comm(THREAD_NAME_02);
428     ftraceEvent->set_allocated_clock_enable_format(clockEnableEvent);
429 
430     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
431     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
432     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
433     auto eventCount =
434         stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLOCK_ENABLE, STAT_EVENT_RECEIVED);
435     EXPECT_TRUE(1 == eventCount);
436 }
437 
438 /**
439  * @tc.name: ParseClockSetRateEvent
440  * @tc.desc: Parse a clock_set_rate event in htrace format
441  * @tc.type: FUNC
442  */
443 HWTEST_F(HtraceEventParserTest, ParseClockSetRateEvent, TestSize.Level1)
444 {
445     ClockSetRateFormat* clockSetRateEvent = new ClockSetRateFormat();
446     clockSetRateEvent->set_name(THREAD_NAME_02);
447     clockSetRateEvent->set_cpu_id(0);
448     clockSetRateEvent->set_state(1);
449 
450     FtraceCpuDetailMsg ftraceCpuDetail;
451     ftraceCpuDetail.set_cpu(0);
452     ftraceCpuDetail.set_overwrite(0);
453     auto ftraceEvent = ftraceCpuDetail.add_event();
454 
455     ftraceEvent->set_timestamp(TIMESTAMP);
456     ftraceEvent->set_tgid(2);
457     ftraceEvent->set_comm(THREAD_NAME_02);
458     ftraceEvent->set_allocated_clock_set_rate_format(clockSetRateEvent);
459 
460     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
461     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
462     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
463     auto eventCount =
464         stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLOCK_SET_RATE, STAT_EVENT_RECEIVED);
465     EXPECT_TRUE(1 == eventCount);
466 }
467 
468 /**
469  * @tc.name: ParseClkDisableEvent
470  * @tc.desc: Parse a clk_Disable event in htrace format
471  * @tc.type: FUNC
472  */
473 HWTEST_F(HtraceEventParserTest, ParseClkDisableEvent, TestSize.Level1)
474 {
475     ClkDisableFormat* clkDisableEvent = new ClkDisableFormat();
476     clkDisableEvent->set_name(THREAD_NAME_02);
477 
478     FtraceCpuDetailMsg ftraceCpuDetail;
479     ftraceCpuDetail.set_cpu(0);
480     ftraceCpuDetail.set_overwrite(0);
481     auto ftraceEvent = ftraceCpuDetail.add_event();
482 
483     ftraceEvent->set_timestamp(TIMESTAMP);
484     ftraceEvent->set_tgid(2);
485     ftraceEvent->set_comm(THREAD_NAME_02);
486     ftraceEvent->set_allocated_clk_disable_format(clkDisableEvent);
487 
488     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
489     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
490     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
491     auto eventCount =
492         stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLK_DISABLE, STAT_EVENT_RECEIVED);
493     EXPECT_TRUE(1 == eventCount);
494 }
495 
496 /**
497  * @tc.name: ParseClkEnableEvent
498  * @tc.desc: Parse a clk_Enable event in htrace format
499  * @tc.type: FUNC
500  */
501 HWTEST_F(HtraceEventParserTest, ParseClkEnableEvent, TestSize.Level1)
502 {
503     ClkEnableFormat* clkEnableEvent = new ClkEnableFormat();
504     clkEnableEvent->set_name(THREAD_NAME_02);
505 
506     FtraceCpuDetailMsg ftraceCpuDetail;
507     ftraceCpuDetail.set_cpu(0);
508     ftraceCpuDetail.set_overwrite(0);
509     auto ftraceEvent = ftraceCpuDetail.add_event();
510 
511     ftraceEvent->set_timestamp(TIMESTAMP);
512     ftraceEvent->set_tgid(2);
513     ftraceEvent->set_comm(THREAD_NAME_02);
514     ftraceEvent->set_allocated_clk_enable_format(clkEnableEvent);
515 
516     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
517     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
518     auto eventCount =
519         stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLK_ENABLE, STAT_EVENT_RECEIVED);
520     EXPECT_TRUE(1 == eventCount);
521 }
522 
523 /**
524  * @tc.name: ParseClkSetRateEvent
525  * @tc.desc: Parse a clk_set_rate event in htrace format
526  * @tc.type: FUNC
527  */
528 HWTEST_F(HtraceEventParserTest, ParseClkSetRateEvent, TestSize.Level1)
529 {
530     ClkSetRateFormat* clkSetRateEvent = new ClkSetRateFormat();
531     clkSetRateEvent->set_name(THREAD_NAME_02);
532     clkSetRateEvent->set_rate(1);
533 
534     FtraceCpuDetailMsg ftraceCpuDetail;
535     ftraceCpuDetail.set_cpu(0);
536     ftraceCpuDetail.set_overwrite(0);
537     auto ftraceEvent = ftraceCpuDetail.add_event();
538 
539     ftraceEvent->set_timestamp(TIMESTAMP);
540     ftraceEvent->set_tgid(2);
541     ftraceEvent->set_comm(THREAD_NAME_02);
542     ftraceEvent->set_allocated_clk_set_rate_format(clkSetRateEvent);
543 
544     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
545     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
546     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
547     auto eventCount =
548         stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLK_SET_RATE, STAT_EVENT_RECEIVED);
549     EXPECT_TRUE(1 == eventCount);
550 }
551 
552 /**
553  * @tc.name: ParseSysEnterEvent
554  * @tc.desc: Parse a sysEnter event in htrace format
555  * @tc.type: FUNC
556  */
557 HWTEST_F(HtraceEventParserTest, ParseSysEnterEvent, TestSize.Level1)
558 {
559     SysEnterFormat* sysEnterEvent = new SysEnterFormat();
560     sysEnterEvent->set_id(1);
561     sysEnterEvent->set_args(THREAD_NAME_02);
562 
563     FtraceCpuDetailMsg ftraceCpuDetail;
564     ftraceCpuDetail.set_cpu(0);
565     ftraceCpuDetail.set_overwrite(0);
566     auto ftraceEvent = ftraceCpuDetail.add_event();
567 
568     ftraceEvent->set_timestamp(TIMESTAMP);
569     ftraceEvent->set_tgid(2);
570     ftraceEvent->set_comm(THREAD_NAME_02);
571     ftraceEvent->set_allocated_sys_enter_format(sysEnterEvent);
572 
573     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
574     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
575     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
576     auto eventCount =
577         stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_SYS_ENTRY, STAT_EVENT_RECEIVED);
578     EXPECT_TRUE(1 == eventCount);
579 }
580 /**
581  * @tc.name: ParseSystemExitEvent
582  * @tc.desc: Parse a system_exit event in htrace format
583  * @tc.type: FUNC
584  */
585 HWTEST_F(HtraceEventParserTest, ParseSystemExitEvent, TestSize.Level1)
586 {
587     SysExitFormat* sysExitEvent = new SysExitFormat();
588     sysExitEvent->set_id(1);
589     sysExitEvent->set_ret(1);
590 
591     FtraceCpuDetailMsg ftraceCpuDetail;
592     ftraceCpuDetail.set_cpu(0);
593     ftraceCpuDetail.set_overwrite(0);
594     auto ftraceEvent = ftraceCpuDetail.add_event();
595 
596     ftraceEvent->set_timestamp(TIMESTAMP);
597     ftraceEvent->set_tgid(2);
598     ftraceEvent->set_comm(THREAD_NAME_02);
599     ftraceEvent->set_allocated_sys_exit_format(sysExitEvent);
600 
601     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
602     eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME);
603     stream_.streamFilters_->cpuFilter_->FinishCpuEvent();
604     auto eventCount =
605         stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_SYS_EXIT, STAT_EVENT_RECEIVED);
606     EXPECT_TRUE(1 == eventCount);
607 }
608 } // namespace TraceStreamer
609 } // namespace SysTuning
610