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 <memory> 20 21 #include "cpu_plugin_result.pb.h" 22 #include "cpu_plugin_result.pbreader.h" 23 #include "htrace_cpu_data_parser.h" 24 #include "parser/bytrace_parser/bytrace_parser.h" 25 #include "parser/common_types.h" 26 #include "trace_streamer_selector.h" 27 28 using namespace testing::ext; 29 using namespace SysTuning::TraceStreamer; 30 31 namespace SysTuning { 32 namespace TraceStreamer { 33 class HtraceCpuDataParserTest : public ::testing::Test { 34 public: SetUp()35 void SetUp() 36 { 37 stream_.InitFilter(); 38 } 39 TearDown() const40 void TearDown() const {} 41 42 public: 43 SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {}; 44 }; 45 46 /** 47 * @tc.name: ParseHtraceWithoutCpuDataData 48 * @tc.desc: Parse a cpu that does not contain any cpudata 49 * @tc.type: FUNC 50 */ 51 HWTEST_F(HtraceCpuDataParserTest, ParseHtraceWithoutCpuData, TestSize.Level1) 52 { 53 TS_LOGI("test11-1"); 54 uint64_t ts = 100; 55 auto cpuInfo = std::make_unique<CpuData>(); 56 std::string cpuData = ""; 57 cpuInfo->SerializeToString(&cpuData); 58 ProtoReader::BytesView cpuInfoData(reinterpret_cast<const uint8_t*>(cpuData.data()), cpuData.size()); 59 HtraceCpuDataParser htraceCpuDataParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 60 htraceCpuDataParser.Parse(cpuInfoData, ts); 61 auto size = stream_.traceDataCache_->GetConstCpuUsageInfoData().Size(); 62 EXPECT_FALSE(size); 63 } 64 65 /** 66 * @tc.name: ParseHtraceWithOneCpuData 67 * @tc.desc: Parse a cpu with one cpudata 68 * @tc.type: FUNC 69 */ 70 HWTEST_F(HtraceCpuDataParserTest, ParseHtraceWithOneCpuData, TestSize.Level1) 71 { 72 TS_LOGI("test11-2"); 73 uint64_t ts = 102; 74 const uint64_t TOTAL_LOAD = 2; 75 const uint64_t USER_LOAD = 42; 76 const uint64_t SYSTEM_LOAD = 32; 77 const uint64_t PROCESS_NUM = 202; 78 79 auto cpuInfo(std::make_unique<CpuData>()); 80 cpuInfo->set_total_load(TOTAL_LOAD); 81 cpuInfo->set_user_load(USER_LOAD); 82 cpuInfo->set_sys_load(SYSTEM_LOAD); 83 cpuInfo->set_process_num(PROCESS_NUM); 84 85 std::string cpuData = ""; 86 cpuInfo->SerializeToString(&cpuData); 87 ProtoReader::BytesView cpuInfoData(reinterpret_cast<const uint8_t*>(cpuData.data()), cpuData.size()); 88 HtraceCpuDataParser htraceCpuDataParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 89 htraceCpuDataParser.Parse(cpuInfoData, ts); 90 htraceCpuDataParser.Finish(); 91 auto size = stream_.traceDataCache_->GetConstCpuUsageInfoData().Size(); 92 EXPECT_FALSE(size); 93 } 94 95 /** 96 * @tc.name: ParseHtraceWithTwoCpuData 97 * @tc.desc: Parse a cpu with two cpudata 98 * @tc.type: FUNC 99 */ 100 HWTEST_F(HtraceCpuDataParserTest, ParseHtraceWithTwoCpuData, TestSize.Level1) 101 { 102 TS_LOGI("test11-3"); 103 uint64_t ts = 103; 104 const uint64_t TOTALLOAD_01 = 2; 105 const uint64_t USERLOAD_01 = 42; 106 const uint64_t SYSTEMLOAD_01 = 32; 107 const uint64_t PROCESS_NUM_01 = 202; 108 109 const uint64_t TOTALLOAD_02 = 3; 110 const uint64_t USERLOAD_02 = 43; 111 const uint64_t SYSTEMLOAD_02 = 33; 112 const uint64_t PROCESS_NUM_02 = 203; 113 114 CpuUsageInfo* cpuUsageInfo01 = new CpuUsageInfo(); 115 auto cpuDataInfo01(std::make_unique<CpuData>()); 116 cpuDataInfo01->set_allocated_cpu_usage_info(cpuUsageInfo01); 117 cpuDataInfo01->set_total_load(TOTALLOAD_01); 118 cpuDataInfo01->set_user_load(USERLOAD_01); 119 cpuDataInfo01->set_sys_load(SYSTEMLOAD_01); 120 cpuDataInfo01->set_process_num(PROCESS_NUM_01); 121 122 std::string cpuData = ""; 123 cpuDataInfo01->SerializeToString(&cpuData); 124 ProtoReader::BytesView cpuInfoData01(reinterpret_cast<const uint8_t*>(cpuData.data()), cpuData.size()); 125 HtraceCpuDataParser htraceCpuDataParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 126 htraceCpuDataParser.Parse(cpuInfoData01, ts); 127 128 CpuUsageInfo* cpuUsageInfo02 = new CpuUsageInfo(); 129 auto cpuDataInfo02(std::make_unique<CpuData>()); 130 cpuDataInfo02->set_allocated_cpu_usage_info(cpuUsageInfo02); 131 cpuDataInfo02->set_total_load(TOTALLOAD_02); 132 cpuDataInfo02->set_user_load(USERLOAD_02); 133 cpuDataInfo02->set_sys_load(SYSTEMLOAD_02); 134 cpuDataInfo02->set_process_num(PROCESS_NUM_02); 135 136 cpuDataInfo02->SerializeToString(&cpuData); 137 ProtoReader::BytesView cpuInfoData02(reinterpret_cast<const uint8_t*>(cpuData.data()), cpuData.size()); 138 htraceCpuDataParser.Parse(cpuInfoData02, ts); 139 htraceCpuDataParser.Finish(); 140 141 auto size = stream_.traceDataCache_->GetConstCpuUsageInfoData().Size(); 142 EXPECT_EQ(1, size); 143 144 auto totalLoad = stream_.traceDataCache_->GetConstCpuUsageInfoData().TotalLoad()[0]; 145 EXPECT_EQ(totalLoad, TOTALLOAD_02); 146 147 auto userLoad = stream_.traceDataCache_->GetConstCpuUsageInfoData().UserLoad()[0]; 148 EXPECT_EQ(userLoad, USERLOAD_02); 149 150 auto systemLoad = stream_.traceDataCache_->GetConstCpuUsageInfoData().SystemLoad()[0]; 151 EXPECT_EQ(systemLoad, SYSTEMLOAD_02); 152 } 153 154 /** 155 * @tc.name: ParseHtraceWithThreeCpuData 156 * @tc.desc: Parse a cpu with Three cpudata 157 * @tc.type: FUNC 158 */ 159 HWTEST_F(HtraceCpuDataParserTest, ParseHtraceWithThreeCpuData, TestSize.Level1) 160 { 161 TS_LOGI("test11-4"); 162 uint64_t ts = 104; 163 const uint64_t TOTALLOAD_01 = 4; 164 const uint64_t USERLOAD_01 = 44; 165 const uint64_t SYSTEMLOAD_01 = 34; 166 const uint64_t PROCESS_NUM_01 = 204; 167 168 const uint64_t TOTALLOAD_02 = 5; 169 const uint64_t USERLOAD_02 = 45; 170 const uint64_t SYSTEMLOAD_02 = 35; 171 const uint64_t PROCESS_NUM_02 = 205; 172 173 const uint64_t TOTALLOAD_03 = 6; 174 const uint64_t USERLOAD_03 = 46; 175 const uint64_t SYSTEMLOAD_03 = 36; 176 const uint64_t PROCESS_NUM_03 = 206; 177 178 CpuUsageInfo* cpuUsageInfo01 = new CpuUsageInfo(); 179 auto cpuDataInfo01(std::make_unique<CpuData>()); 180 cpuDataInfo01->set_allocated_cpu_usage_info(cpuUsageInfo01); 181 cpuDataInfo01->set_total_load(TOTALLOAD_01); 182 cpuDataInfo01->set_user_load(USERLOAD_01); 183 cpuDataInfo01->set_sys_load(SYSTEMLOAD_01); 184 cpuDataInfo01->set_process_num(PROCESS_NUM_01); 185 186 std::string cpuData = ""; 187 cpuDataInfo01->SerializeToString(&cpuData); 188 ProtoReader::BytesView cpuInfoData01(reinterpret_cast<const uint8_t*>(cpuData.data()), cpuData.size()); 189 HtraceCpuDataParser htraceCpuDataParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 190 htraceCpuDataParser.Parse(cpuInfoData01, ts); 191 192 CpuUsageInfo* cpuUsageInfo02 = new CpuUsageInfo(); 193 auto cpuDataInfo02(std::make_unique<CpuData>()); 194 cpuDataInfo02->set_allocated_cpu_usage_info(cpuUsageInfo02); 195 cpuDataInfo02->set_total_load(TOTALLOAD_02); 196 cpuDataInfo02->set_user_load(USERLOAD_02); 197 cpuDataInfo02->set_sys_load(SYSTEMLOAD_02); 198 cpuDataInfo02->set_process_num(PROCESS_NUM_02); 199 200 cpuDataInfo02->SerializeToString(&cpuData); 201 ProtoReader::BytesView cpuInfoData02(reinterpret_cast<const uint8_t*>(cpuData.data()), cpuData.size()); 202 htraceCpuDataParser.Parse(cpuInfoData02, ts); 203 204 CpuUsageInfo* cpuUsageInfo03 = new CpuUsageInfo(); 205 auto cpuDataInfo03(std::make_unique<CpuData>()); 206 cpuDataInfo03->set_allocated_cpu_usage_info(cpuUsageInfo03); 207 cpuDataInfo03->set_total_load(TOTALLOAD_03); 208 cpuDataInfo03->set_user_load(USERLOAD_03); 209 cpuDataInfo03->set_sys_load(SYSTEMLOAD_03); 210 cpuDataInfo03->set_process_num(PROCESS_NUM_03); 211 212 cpuDataInfo03->SerializeToString(&cpuData); 213 ProtoReader::BytesView cpuInfoData03(reinterpret_cast<const uint8_t*>(cpuData.data()), cpuData.size()); 214 htraceCpuDataParser.Parse(cpuInfoData03, ts); 215 htraceCpuDataParser.Finish(); 216 217 auto size = stream_.traceDataCache_->GetConstCpuUsageInfoData().Size(); 218 EXPECT_EQ(2, size); 219 220 auto totalLoadFirst = stream_.traceDataCache_->GetConstCpuUsageInfoData().TotalLoad()[0]; 221 auto totalLoadSecond = stream_.traceDataCache_->GetConstCpuUsageInfoData().TotalLoad()[1]; 222 EXPECT_EQ(totalLoadFirst, TOTALLOAD_02); 223 EXPECT_EQ(totalLoadSecond, TOTALLOAD_03); 224 225 auto userLoadFirst = stream_.traceDataCache_->GetConstCpuUsageInfoData().UserLoad()[0]; 226 auto userLoadSecond = stream_.traceDataCache_->GetConstCpuUsageInfoData().UserLoad()[1]; 227 EXPECT_EQ(userLoadFirst, USERLOAD_02); 228 EXPECT_EQ(userLoadSecond, USERLOAD_03); 229 230 auto systemLoadFirst = stream_.traceDataCache_->GetConstCpuUsageInfoData().SystemLoad()[0]; 231 auto systemLoadSecond = stream_.traceDataCache_->GetConstCpuUsageInfoData().SystemLoad()[1]; 232 EXPECT_EQ(systemLoadFirst, SYSTEMLOAD_02); 233 EXPECT_EQ(systemLoadSecond, SYSTEMLOAD_03); 234 } 235 236 /** 237 * @tc.name: ParseHtraceWithMultipleCpuData 238 * @tc.desc: Parse a CpuData with Multiple CpuData 239 * @tc.type: FUNC 240 */ 241 HWTEST_F(HtraceCpuDataParserTest, ParseHtraceWithMultipleCpuData, TestSize.Level1) 242 { 243 TS_LOGI("test11-5"); 244 uint64_t ts = 104; 245 const uint64_t TOTALLOAD_01 = 4; 246 const uint64_t USERLOAD_01 = 44; 247 const uint64_t SYSTEMLOAD_01 = 34; 248 const uint64_t PROCESS_NUM_01 = 204; 249 250 const uint64_t TOTALLOAD_02 = 5; 251 const uint64_t USERLOAD_02 = 45; 252 const uint64_t SYSTEMLOAD_02 = 35; 253 const uint64_t PROCESS_NUM_02 = 205; 254 255 const uint64_t TOTALLOAD_03 = 6; 256 const uint64_t USERLOAD_03 = 46; 257 const uint64_t SYSTEMLOAD_03 = 36; 258 const uint64_t PROCESS_NUM_03 = 206; 259 260 const uint64_t TOTALLOAD_04 = 6; 261 const uint64_t USERLOAD_04 = 46; 262 const uint64_t SYSTEMLOAD_04 = 36; 263 const uint64_t PROCESS_NUM_04 = 206; 264 265 CpuUsageInfo* cpuUsageInfo01 = new CpuUsageInfo(); 266 auto cpuDataInfo01(std::make_unique<CpuData>()); 267 cpuDataInfo01->set_allocated_cpu_usage_info(cpuUsageInfo01); 268 cpuDataInfo01->set_total_load(TOTALLOAD_01); 269 cpuDataInfo01->set_user_load(USERLOAD_01); 270 cpuDataInfo01->set_sys_load(SYSTEMLOAD_01); 271 cpuDataInfo01->set_process_num(PROCESS_NUM_01); 272 273 std::string cpuData = ""; 274 cpuDataInfo01->SerializeToString(&cpuData); 275 ProtoReader::BytesView cpuInfoData01(reinterpret_cast<const uint8_t*>(cpuData.data()), cpuData.size()); 276 HtraceCpuDataParser htraceCpuDataParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 277 htraceCpuDataParser.Parse(cpuInfoData01, ts); 278 279 CpuUsageInfo* cpuUsageInfo02 = new CpuUsageInfo(); 280 auto cpuDataInfo02(std::make_unique<CpuData>()); 281 cpuDataInfo02->set_allocated_cpu_usage_info(cpuUsageInfo02); 282 cpuDataInfo02->set_total_load(TOTALLOAD_02); 283 cpuDataInfo02->set_user_load(USERLOAD_02); 284 cpuDataInfo02->set_sys_load(SYSTEMLOAD_02); 285 cpuDataInfo02->set_process_num(PROCESS_NUM_02); 286 287 cpuDataInfo02->SerializeToString(&cpuData); 288 ProtoReader::BytesView cpuInfoData02(reinterpret_cast<const uint8_t*>(cpuData.data()), cpuData.size()); 289 htraceCpuDataParser.Parse(cpuInfoData02, ts); 290 291 CpuUsageInfo* cpuUsageInfo03 = new CpuUsageInfo(); 292 auto cpuDataInfo03(std::make_unique<CpuData>()); 293 cpuDataInfo03->set_allocated_cpu_usage_info(cpuUsageInfo03); 294 cpuDataInfo03->set_total_load(TOTALLOAD_03); 295 cpuDataInfo03->set_user_load(USERLOAD_03); 296 cpuDataInfo03->set_sys_load(SYSTEMLOAD_03); 297 cpuDataInfo03->set_process_num(PROCESS_NUM_03); 298 299 cpuDataInfo03->SerializeToString(&cpuData); 300 ProtoReader::BytesView cpuInfoData03(reinterpret_cast<const uint8_t*>(cpuData.data()), cpuData.size()); 301 htraceCpuDataParser.Parse(cpuInfoData03, ts); 302 303 CpuUsageInfo* cpuUsageInfo04 = new CpuUsageInfo(); 304 auto cpuDataInfo04(std::make_unique<CpuData>()); 305 cpuDataInfo04->set_allocated_cpu_usage_info(cpuUsageInfo04); 306 cpuDataInfo04->set_total_load(TOTALLOAD_04); 307 cpuDataInfo04->set_user_load(USERLOAD_04); 308 cpuDataInfo04->set_sys_load(SYSTEMLOAD_04); 309 cpuDataInfo04->set_process_num(PROCESS_NUM_04); 310 311 cpuDataInfo04->SerializeToString(&cpuData); 312 ProtoReader::BytesView cpuInfoData04(reinterpret_cast<const uint8_t*>(cpuData.data()), cpuData.size()); 313 htraceCpuDataParser.Parse(cpuInfoData04, ts); 314 htraceCpuDataParser.Finish(); 315 316 auto size = stream_.traceDataCache_->GetConstCpuUsageInfoData().Size(); 317 EXPECT_EQ(3, size); 318 319 auto totalLoadFirst = stream_.traceDataCache_->GetConstCpuUsageInfoData().TotalLoad()[0]; 320 auto totalLoadSecond = stream_.traceDataCache_->GetConstCpuUsageInfoData().TotalLoad()[1]; 321 auto totalLoadThird = stream_.traceDataCache_->GetConstCpuUsageInfoData().TotalLoad()[2]; 322 EXPECT_EQ(totalLoadFirst, TOTALLOAD_02); 323 EXPECT_EQ(totalLoadSecond, TOTALLOAD_03); 324 EXPECT_EQ(totalLoadThird, TOTALLOAD_04); 325 326 auto userLoadFirst = stream_.traceDataCache_->GetConstCpuUsageInfoData().UserLoad()[0]; 327 auto userLoadSecond = stream_.traceDataCache_->GetConstCpuUsageInfoData().UserLoad()[1]; 328 auto userLoadThird = stream_.traceDataCache_->GetConstCpuUsageInfoData().UserLoad()[2]; 329 EXPECT_EQ(userLoadFirst, USERLOAD_02); 330 EXPECT_EQ(userLoadSecond, USERLOAD_03); 331 EXPECT_EQ(userLoadThird, USERLOAD_04); 332 333 auto systemLoadFirst = stream_.traceDataCache_->GetConstCpuUsageInfoData().SystemLoad()[0]; 334 auto systemLoadSecond = stream_.traceDataCache_->GetConstCpuUsageInfoData().SystemLoad()[1]; 335 auto systemLoadThird = stream_.traceDataCache_->GetConstCpuUsageInfoData().SystemLoad()[2]; 336 EXPECT_EQ(systemLoadFirst, SYSTEMLOAD_02); 337 EXPECT_EQ(systemLoadSecond, SYSTEMLOAD_03); 338 EXPECT_EQ(systemLoadThird, SYSTEMLOAD_04); 339 } 340 } // namespace TraceStreamer 341 } // namespace SysTuning 342