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