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_process_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 HtraceProcessParserTest : public ::testing::Test { 32 public: SetUp()33 void SetUp() 34 { 35 stream_.InitFilter(); 36 } 37 TearDown()38 void TearDown() {} 39 40 public: 41 SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {}; 42 }; 43 44 /** 45 * @tc.name: ParseHtraceProcessWithoutProcessData 46 * @tc.desc: Parse a Process that does not contain any ProcessData 47 * @tc.type: FUNC 48 */ 49 HWTEST_F(HtraceProcessParserTest, ParseHtraceProcessWithoutProcessData, TestSize.Level1) 50 { 51 TS_LOGI("test18-1"); 52 auto processData = std::make_unique<ProcessData>(); 53 uint64_t ts = 100; 54 HtraceProcessParser htraceProcessParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 55 htraceProcessParser.Parse(*processData, ts); 56 auto size = stream_.traceDataCache_->GetConstLiveProcessData().Size(); 57 EXPECT_FALSE(size); 58 } 59 60 /** 61 * @tc.name: ParseHtraceProcessWithProcessData 62 * @tc.desc: Parse a Process with ProcessData 63 * @tc.type: FUNC 64 */ 65 HWTEST_F(HtraceProcessParserTest, ParseHtraceProcessWithProcessData, TestSize.Level1) 66 { 67 TS_LOGI("test18-2"); 68 uint64_t ts = 100; 69 const uint32_t PID = 312; 70 const string NAME = "resource_schedu"; 71 const int32_t PPID = 22; 72 const int32_t UID = 23; 73 74 auto processData = std::make_unique<ProcessData>(); 75 ProcessInfo* processInfo = processData->add_processesinfo(); 76 processInfo->set_pid(PID); 77 processInfo->set_name(NAME); 78 processInfo->set_ppid(PPID); 79 processInfo->set_uid(UID); 80 81 HtraceProcessParser htraceProcessParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 82 htraceProcessParser.Parse(*processData, ts); 83 htraceProcessParser.Finish(); 84 85 auto size = stream_.traceDataCache_->GetConstLiveProcessData().Size(); 86 EXPECT_FALSE(size); 87 } 88 89 /** 90 * @tc.name: ParseHtraceProcessWithTwoProcessData 91 * @tc.desc: Parse a Process with ProcessData 92 * @tc.type: FUNC 93 */ 94 HWTEST_F(HtraceProcessParserTest, ParseHtraceProcessWithTwoProcessData, TestSize.Level1) 95 { 96 TS_LOGI("test18-3"); 97 uint64_t ts = 100; 98 const uint32_t PID_01 = 311; 99 const string NAME_01 = "resource_schedu01"; 100 const int32_t PPID_01 = 21; 101 const int32_t UID_01 = 1; 102 103 const uint32_t PID_02 = 312; 104 const string NAME_02 = "resource_schedu02"; 105 const int32_t PPID_02 = 22; 106 const int32_t UID_02 = 2; 107 108 auto processData = std::make_unique<ProcessData>(); 109 ProcessInfo* processInfoFirst = processData->add_processesinfo(); 110 processInfoFirst->set_pid(PID_01); 111 processInfoFirst->set_name(NAME_01); 112 processInfoFirst->set_ppid(PPID_01); 113 processInfoFirst->set_uid(UID_01); 114 115 ProcessInfo* processInfoSecond = processData->add_processesinfo(); 116 processInfoSecond->set_pid(PID_02); 117 processInfoSecond->set_name(NAME_02); 118 processInfoSecond->set_ppid(PPID_02); 119 processInfoSecond->set_uid(UID_02); 120 121 HtraceProcessParser htraceProcessParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 122 htraceProcessParser.Parse(*processData, ts); 123 htraceProcessParser.Finish(); 124 125 auto size = stream_.traceDataCache_->GetConstLiveProcessData().Size(); 126 EXPECT_EQ(1, size); 127 128 auto pidFirst = stream_.traceDataCache_->GetConstLiveProcessData().ProcessID()[0]; 129 EXPECT_EQ(pidFirst, PID_02); 130 auto processNameFirst = stream_.traceDataCache_->GetConstLiveProcessData().ProcessName()[0]; 131 EXPECT_EQ(processNameFirst, NAME_02); 132 auto parentProcessIDFirst = stream_.traceDataCache_->GetConstLiveProcessData().ParentProcessID()[0]; 133 EXPECT_EQ(parentProcessIDFirst, PPID_02); 134 auto uidFirst = stream_.traceDataCache_->GetConstLiveProcessData().Uid()[0]; 135 EXPECT_EQ(uidFirst, UID_02); 136 auto userNameFirst = stream_.traceDataCache_->GetConstLiveProcessData().UserName()[0]; 137 EXPECT_EQ(userNameFirst, std::to_string(UID_02)); 138 } 139 140 /** 141 * @tc.name: ParseHtraceProcessWithThreeProcessData 142 * @tc.desc: Parse a Process with ProcessData 143 * @tc.type: FUNC 144 */ 145 HWTEST_F(HtraceProcessParserTest, ParseHtraceProcessWithThreeProcessData, TestSize.Level1) 146 { 147 TS_LOGI("test18-4"); 148 uint64_t ts = 100; 149 const uint32_t PID_01 = 311; 150 const string NAME_01 = "resource_schedu01"; 151 const int32_t PPID_01 = 21; 152 const int32_t UID_01 = 1; 153 154 const uint32_t PID_02 = 312; 155 const string NAME_02 = "resource_schedu02"; 156 const int32_t PPID_02 = 22; 157 const int32_t UID_02 = 2; 158 159 const uint32_t PID_03 = 313; 160 const string NAME_03 = "resource_schedu03"; 161 const int32_t PPID_03 = 23; 162 const int32_t UID_03 = 3; 163 164 auto processData = std::make_unique<ProcessData>(); 165 ProcessInfo* processInfoFirst = processData->add_processesinfo(); 166 processInfoFirst->set_pid(PID_01); 167 processInfoFirst->set_name(NAME_01); 168 processInfoFirst->set_ppid(PPID_01); 169 processInfoFirst->set_uid(UID_01); 170 171 ProcessInfo* processInfoSecond = processData->add_processesinfo(); 172 processInfoSecond->set_pid(PID_02); 173 processInfoSecond->set_name(NAME_02); 174 processInfoSecond->set_ppid(PPID_02); 175 processInfoSecond->set_uid(UID_02); 176 177 ProcessInfo* processInfoThird = processData->add_processesinfo(); 178 processInfoThird->set_pid(PID_03); 179 processInfoThird->set_name(NAME_03); 180 processInfoThird->set_ppid(PPID_03); 181 processInfoThird->set_uid(UID_03); 182 183 HtraceProcessParser htraceProcessParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 184 htraceProcessParser.Parse(*processData, ts); 185 htraceProcessParser.Finish(); 186 187 auto pidFirst = stream_.traceDataCache_->GetConstLiveProcessData().ProcessID()[0]; 188 auto pidSecond = stream_.traceDataCache_->GetConstLiveProcessData().ProcessID()[1]; 189 EXPECT_EQ(pidFirst, PID_02); 190 EXPECT_EQ(pidSecond, PID_03); 191 auto processNameFirst = stream_.traceDataCache_->GetConstLiveProcessData().ProcessName()[0]; 192 auto processNameSecond = stream_.traceDataCache_->GetConstLiveProcessData().ProcessName()[1]; 193 EXPECT_EQ(processNameFirst, NAME_02); 194 EXPECT_EQ(processNameSecond, NAME_03); 195 auto parentProcessIDFirst = stream_.traceDataCache_->GetConstLiveProcessData().ParentProcessID()[0]; 196 auto parentProcessIDSecond = stream_.traceDataCache_->GetConstLiveProcessData().ParentProcessID()[1]; 197 EXPECT_EQ(parentProcessIDFirst, PPID_02); 198 EXPECT_EQ(parentProcessIDSecond, PPID_03); 199 auto uidFirst = stream_.traceDataCache_->GetConstLiveProcessData().Uid()[0]; 200 auto uidSecond = stream_.traceDataCache_->GetConstLiveProcessData().Uid()[1]; 201 EXPECT_EQ(uidFirst, UID_02); 202 EXPECT_EQ(uidSecond, UID_03); 203 auto userNameFirst = stream_.traceDataCache_->GetConstLiveProcessData().UserName()[0]; 204 auto userNameSecond = stream_.traceDataCache_->GetConstLiveProcessData().UserName()[1]; 205 EXPECT_EQ(userNameFirst, std::to_string(UID_02)); 206 EXPECT_EQ(userNameSecond, std::to_string(UID_03)); 207 } 208 209 /** 210 * @tc.name: ParseHtraceProcessWithMultipleProcessData 211 * @tc.desc: Parse a Process with ProcessData 212 * @tc.type: FUNC 213 */ 214 HWTEST_F(HtraceProcessParserTest, ParseHtraceProcessWithMultipleProcessData, TestSize.Level1) 215 { 216 TS_LOGI("test18-5"); 217 uint64_t ts = 100; 218 const uint32_t PID_01 = 311; 219 const string NAME_01 = "resource_schedu01"; 220 const int32_t PPID_01 = 21; 221 const int32_t UID_01 = 1; 222 223 const uint32_t PID_02 = 312; 224 const string NAME_02 = "resource_schedu02"; 225 const int32_t PPID_02 = 22; 226 const int32_t UID_02 = 2; 227 228 const uint32_t PID_03 = 313; 229 const string NAME_03 = "resource_schedu03"; 230 const int32_t PPID_03 = 23; 231 const int32_t UID_03 = 3; 232 233 const uint32_t PID_04 = 313; 234 const string NAME_04 = "resource_schedu03"; 235 const int32_t PPID_04 = 23; 236 const int32_t UID_04 = 3; 237 238 auto processData = std::make_unique<ProcessData>(); 239 ProcessInfo* processInfoFirst = processData->add_processesinfo(); 240 processInfoFirst->set_pid(PID_01); 241 processInfoFirst->set_name(NAME_01); 242 processInfoFirst->set_ppid(PPID_01); 243 processInfoFirst->set_uid(UID_01); 244 245 ProcessInfo* processInfoSecond = processData->add_processesinfo(); 246 processInfoSecond->set_pid(PID_02); 247 processInfoSecond->set_name(NAME_02); 248 processInfoSecond->set_ppid(PPID_02); 249 processInfoSecond->set_uid(UID_02); 250 251 ProcessInfo* processInfoThird = processData->add_processesinfo(); 252 processInfoThird->set_pid(PID_03); 253 processInfoThird->set_name(NAME_03); 254 processInfoThird->set_ppid(PPID_03); 255 processInfoThird->set_uid(UID_03); 256 257 ProcessInfo* processInfoFour = processData->add_processesinfo(); 258 processInfoFour->set_pid(PID_04); 259 processInfoFour->set_name(NAME_04); 260 processInfoFour->set_ppid(PPID_04); 261 processInfoFour->set_uid(UID_04); 262 263 HtraceProcessParser htraceProcessParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 264 htraceProcessParser.Parse(*processData, ts); 265 htraceProcessParser.Finish(); 266 267 auto pidFirst = stream_.traceDataCache_->GetConstLiveProcessData().ProcessID()[0]; 268 auto pidSecond = stream_.traceDataCache_->GetConstLiveProcessData().ProcessID()[1]; 269 auto pidThird = stream_.traceDataCache_->GetConstLiveProcessData().ProcessID()[2]; 270 EXPECT_EQ(pidFirst, PID_02); 271 EXPECT_EQ(pidSecond, PID_03); 272 EXPECT_EQ(pidThird, PID_04); 273 auto processNameFirst = stream_.traceDataCache_->GetConstLiveProcessData().ProcessName()[0]; 274 auto processNameSecond = stream_.traceDataCache_->GetConstLiveProcessData().ProcessName()[1]; 275 auto processNameThird = stream_.traceDataCache_->GetConstLiveProcessData().ProcessName()[2]; 276 EXPECT_EQ(processNameFirst, NAME_02); 277 EXPECT_EQ(processNameSecond, NAME_03); 278 EXPECT_EQ(processNameThird, NAME_04); 279 auto parentProcessIDFirst = stream_.traceDataCache_->GetConstLiveProcessData().ParentProcessID()[0]; 280 auto parentProcessIDSecond = stream_.traceDataCache_->GetConstLiveProcessData().ParentProcessID()[1]; 281 auto parentProcessIDThird = stream_.traceDataCache_->GetConstLiveProcessData().ParentProcessID()[2]; 282 EXPECT_EQ(parentProcessIDFirst, PPID_02); 283 EXPECT_EQ(parentProcessIDSecond, PPID_03); 284 EXPECT_EQ(parentProcessIDThird, PPID_04); 285 auto uidFirst = stream_.traceDataCache_->GetConstLiveProcessData().Uid()[0]; 286 auto uidSecond = stream_.traceDataCache_->GetConstLiveProcessData().Uid()[1]; 287 auto uidThird = stream_.traceDataCache_->GetConstLiveProcessData().Uid()[2]; 288 EXPECT_EQ(uidFirst, UID_02); 289 EXPECT_EQ(uidSecond, UID_03); 290 EXPECT_EQ(uidThird, UID_04); 291 auto userNameFirst = stream_.traceDataCache_->GetConstLiveProcessData().UserName()[0]; 292 auto userNameSecond = stream_.traceDataCache_->GetConstLiveProcessData().UserName()[1]; 293 auto userNameThird = stream_.traceDataCache_->GetConstLiveProcessData().UserName()[2]; 294 EXPECT_EQ(userNameFirst, std::to_string(UID_02)); 295 EXPECT_EQ(userNameSecond, std::to_string(UID_03)); 296 EXPECT_EQ(userNameThird, std::to_string(UID_04)); 297 } 298 } // namespace TraceStreamer 299 } // namespace SysTuning