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 "power.pb.h" 22 #include "stat_filter.h" 23 #include "trace_streamer_selector.h" 24 #include "trace_plugin_result.pb.h" 25 #include "trace_plugin_result.pbreader.h" 26 27 using namespace testing::ext; 28 using namespace SysTuning::TraceStreamer; 29 30 namespace SysTuning { 31 namespace TraceStreamer { 32 class HtraceCpuDetailParserTest : public ::testing::Test { 33 public: SetUp()34 void SetUp() 35 { 36 stream_.InitFilter(); 37 } 38 TearDown() const39 void TearDown() const {} 40 41 public: 42 SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {}; 43 }; 44 45 /** 46 * @tc.name: ParseCpudetaulNoEvents 47 * @tc.desc: Parse a cpudetaul with no events 48 * @tc.type: FUNC 49 */ 50 HWTEST_F(HtraceCpuDetailParserTest, ParseCpudetaulNoEvents, TestSize.Level1) 51 { 52 TS_LOGI("test12-1"); 53 TracePluginResult tracePacket; 54 FtraceCpuDetailMsg* cpuDetail = tracePacket.add_ftrace_cpu_detail(); 55 56 HtraceDataSegment dataSeg; 57 dataSeg.clockId = TS_CLOCK_REALTIME; 58 std::string cpuDetailStrMsg = ""; 59 tracePacket.SerializeToString(&cpuDetailStrMsg); 60 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 61 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 62 cpuDetailStrMsg.size()); 63 dataSeg.protoData = cpuDetailBytesView; 64 65 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 66 htraceCpuDetailParser.Parse(dataSeg, dataSeg.clockId); 67 htraceCpuDetailParser.FilterAllEvents(); 68 auto size = tracePacket.ftrace_cpu_detail_size(); 69 auto eventSize = cpuDetail->event_size(); 70 EXPECT_EQ(size, 1); 71 EXPECT_EQ(eventSize, 0); 72 } 73 /** 74 * @tc.name: ParseHtraceWithoutCpuDetailData 75 * @tc.desc: Parse a cpu that does not contain any cpudetail 76 * @tc.type: FUNC 77 */ 78 HWTEST_F(HtraceCpuDetailParserTest, ParseHtraceWithoutCpuDetailData, TestSize.Level1) 79 { 80 TS_LOGI("test12-2"); 81 TracePluginResult tracePacket; 82 FtraceCpuDetailMsg* cpuDetail = tracePacket.add_ftrace_cpu_detail(); 83 auto event = cpuDetail->add_event(); 84 85 HtraceDataSegment dataSeg; 86 dataSeg.clockId = TS_CLOCK_REALTIME; 87 88 std::string cpuDetailStrMsg = ""; 89 tracePacket.SerializeToString(&cpuDetailStrMsg); 90 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 91 cpuDetailStrMsg.size()); 92 dataSeg.protoData = cpuDetailBytesView; 93 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 94 htraceCpuDetailParser.Parse(dataSeg, dataSeg.clockId); 95 htraceCpuDetailParser.FilterAllEvents(); 96 auto size = tracePacket.ftrace_cpu_detail_size(); 97 auto eventSize = cpuDetail->event_size(); 98 EXPECT_EQ(size, 1); 99 EXPECT_EQ(eventSize, 1); 100 } 101 /** 102 * @tc.name: ParseHtraceCpuDetailData 103 * @tc.desc: Parse a cpudetail data 104 * @tc.type: FUNC 105 */ 106 HWTEST_F(HtraceCpuDetailParserTest, ParseHtraceCpuDetailData, TestSize.Level1) 107 { 108 TS_LOGI("test12-3"); 109 TracePluginResult tracePacket; 110 FtraceCpuDetailMsg* cpuDetail = tracePacket.add_ftrace_cpu_detail(); 111 auto event = cpuDetail->add_event(); 112 cpuDetail->set_cpu(1); 113 event->set_timestamp(1501983446213000000); 114 event->set_tgid(1); 115 CpuFrequencyFormat* freq = new CpuFrequencyFormat(); 116 freq->set_cpu_id(1); 117 freq->set_state(1500); 118 event->set_allocated_cpu_frequency_format(freq); 119 120 HtraceDataSegment dataSeg; 121 dataSeg.clockId = TS_CLOCK_REALTIME; 122 123 std::string cpuDetailStrMsg = ""; 124 tracePacket.SerializeToString(&cpuDetailStrMsg); 125 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 126 cpuDetailStrMsg.size()); 127 dataSeg.protoData = cpuDetailBytesView; 128 129 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 130 htraceCpuDetailParser.Parse(dataSeg, dataSeg.clockId); 131 htraceCpuDetailParser.FilterAllEvents(); 132 auto size = tracePacket.ftrace_cpu_detail_size(); 133 auto eventSize = cpuDetail->event_size(); 134 auto state = stream_.traceDataCache_->GetConstMeasureData().ValuesData()[0]; 135 EXPECT_EQ(size, 1); 136 EXPECT_EQ(eventSize, 1); 137 EXPECT_EQ(state, 1500); 138 } 139 /** 140 * @tc.name: ParseMultipleCpuDetailData 141 * @tc.desc: Parse multiple cpudetail data 142 * @tc.type: FUNC 143 */ 144 HWTEST_F(HtraceCpuDetailParserTest, ParseMultipleCpuDetailData, TestSize.Level1) 145 { 146 TS_LOGI("test12-4"); 147 TracePluginResult tracePacket; 148 FtraceCpuDetailMsg* cpuDetail = tracePacket.add_ftrace_cpu_detail(); 149 auto event = cpuDetail->add_event(); 150 cpuDetail->set_cpu(1); 151 event->set_timestamp(1501983446213000000); 152 event->set_tgid(1); 153 CpuFrequencyFormat* freq0 = new CpuFrequencyFormat(); 154 freq0->set_cpu_id(1); 155 freq0->set_state(1500); 156 event->set_allocated_cpu_frequency_format(freq0); 157 158 cpuDetail = tracePacket.add_ftrace_cpu_detail(); 159 event = cpuDetail->add_event(); 160 cpuDetail->set_cpu(1); 161 event->set_timestamp(1501983446213000000); 162 event->set_tgid(1); 163 CpuFrequencyFormat* freq1 = new CpuFrequencyFormat(); 164 freq1->set_cpu_id(2); 165 freq1->set_state(3000); 166 event->set_allocated_cpu_frequency_format(freq1); 167 168 HtraceDataSegment dataSeg; 169 dataSeg.clockId = TS_CLOCK_REALTIME; 170 171 std::string cpuDetailStrMsg = ""; 172 tracePacket.SerializeToString(&cpuDetailStrMsg); 173 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 174 cpuDetailStrMsg.size()); 175 dataSeg.protoData = cpuDetailBytesView; 176 177 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 178 htraceCpuDetailParser.Parse(dataSeg, dataSeg.clockId); 179 htraceCpuDetailParser.FilterAllEvents(); 180 auto size = tracePacket.ftrace_cpu_detail_size(); 181 auto eventSize = cpuDetail->event_size(); 182 auto state0 = stream_.traceDataCache_->GetConstMeasureData().ValuesData()[0]; 183 auto cpuId0 = stream_.traceDataCache_->GetConstMeasureData().FilterIdData()[0]; 184 auto state1 = stream_.traceDataCache_->GetConstMeasureData().ValuesData()[1]; 185 auto cpuId1 = stream_.traceDataCache_->GetConstMeasureData().FilterIdData()[1]; 186 EXPECT_EQ(size, 2); 187 EXPECT_EQ(eventSize, 1); 188 EXPECT_EQ(state0, 1500); 189 EXPECT_EQ(state1, 3000); 190 } 191 } // namespace TraceStreamer 192 } // namespace SysTuning 193