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 <string> 20 #include <unordered_map> 21 22 23 #include "htrace_mem_parser.h" 24 #include "parser/common_types.h" 25 #include "trace_streamer_selector.h" 26 27 using namespace testing::ext; 28 using namespace SysTuning::TraceStreamer; 29 30 namespace SysTuning { 31 namespace TraceStreamer { 32 class HtraceMemParserTest : public ::testing::Test { 33 public: SetUp()34 void SetUp() 35 { 36 stream_.InitFilter(); 37 } 38 TearDown()39 void TearDown() 40 { 41 if (access(dbPath_.c_str(), F_OK) == 0) { 42 remove(dbPath_.c_str()); 43 } 44 } 45 46 public: 47 SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {}; 48 const std::string dbPath_ = "data/resource/out.db"; 49 }; 50 51 /** 52 * @tc.name: ParseMemParse 53 * @tc.desc: Parse MemoryData object and export database 54 * @tc.type: FUNC 55 */ 56 HWTEST_F(HtraceMemParserTest, ParseMemParse, TestSize.Level1) 57 { 58 TS_LOGI("test16-1"); 59 HtraceMemParser* memParser = new HtraceMemParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 60 61 MemoryData tracePacket; 62 ProcessMemoryInfo* memoryInfo = tracePacket.add_processesinfo(); 63 EXPECT_TRUE(memoryInfo != nullptr); 64 int size = tracePacket.processesinfo_size(); 65 EXPECT_TRUE(size == 1); 66 uint64_t timeStamp = 1616439852302; 67 BuiltinClocks clock = TS_CLOCK_REALTIME; 68 69 memParser->Parse(tracePacket, timeStamp, clock); 70 memParser->Finish(); 71 stream_.traceDataCache_->ExportDatabase(dbPath_); 72 73 EXPECT_TRUE(access(dbPath_.c_str(), F_OK) == 0); 74 tracePacket.clear_processesinfo(); 75 delete memParser; 76 77 auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_MEMORY, STAT_EVENT_RECEIVED); 78 EXPECT_TRUE(1 == eventCount); 79 } 80 81 /** 82 * @tc.name: ParseMemParseTestMeasureDataSize 83 * @tc.desc: Parse MemoryData object and count StatInfo 84 * @tc.type: FUNC 85 */ 86 HWTEST_F(HtraceMemParserTest, ParseMemParseTestMeasureDataSize, TestSize.Level1) 87 { 88 TS_LOGI("test16-2"); 89 HtraceMemParser* memParser = new HtraceMemParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 90 91 MemoryData tracePacket; 92 ProcessMemoryInfo* memoryInfo = tracePacket.add_processesinfo(); 93 EXPECT_TRUE(memoryInfo != nullptr); 94 int size = tracePacket.processesinfo_size(); 95 EXPECT_TRUE(size == 1); 96 uint64_t timeStamp = 1616439852302; 97 BuiltinClocks clock = TS_CLOCK_REALTIME; 98 uint32_t pid = 12; 99 int64_t memKb = 1024; 100 int64_t memRssKb = 512; 101 int64_t memAnonKb = 128; 102 int64_t memFileKb = 2048; 103 memoryInfo->set_pid(pid); 104 memoryInfo->set_name("Process1"); 105 memoryInfo->set_vm_size_kb(memKb); 106 memoryInfo->set_vm_rss_kb(memRssKb); 107 memoryInfo->set_rss_anon_kb(memAnonKb); 108 memoryInfo->set_rss_file_kb(memFileKb); 109 110 memParser->Parse(tracePacket, timeStamp, clock); 111 memParser->Finish(); 112 stream_.traceDataCache_->ExportDatabase(dbPath_); 113 114 EXPECT_TRUE(access(dbPath_.c_str(), F_OK) == 0); 115 tracePacket.clear_processesinfo(); 116 delete memParser; 117 118 auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_MEMORY, STAT_EVENT_RECEIVED); 119 EXPECT_TRUE(1 == eventCount); 120 121 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessData(1).pid_ == pid); 122 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessMeasureData().Size() == MEM_MAX * 1); 123 EXPECT_EQ(stream_.traceDataCache_->GetConstProcessData().size(), 2); 124 125 for (auto i = 0; i < MEM_MAX; i++) { 126 if (stream_.traceDataCache_->GetConstProcessMeasureData().filterIdDeque_[i] == 127 memParser->memNameDictMap_.at(MEM_VM_SIZE)) { 128 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessMeasureData().valuesDeque_[i] == memKb); 129 } else if (stream_.traceDataCache_->GetConstProcessMeasureData().filterIdDeque_[i] == 130 memParser->memNameDictMap_.at(MEM_VM_RSS)) { 131 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessMeasureData().valuesDeque_[i] == memRssKb); 132 } else if (stream_.traceDataCache_->GetConstProcessMeasureData().filterIdDeque_[i] == 133 memParser->memNameDictMap_.at(MEM_VM_ANON)) { 134 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessMeasureData().valuesDeque_[i] == memAnonKb); 135 } else if (stream_.traceDataCache_->GetConstProcessMeasureData().filterIdDeque_[i] == 136 memParser->memNameDictMap_.at(MEM_RSS_FILE)) { 137 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessMeasureData().valuesDeque_[i] == memFileKb); 138 } 139 } 140 } 141 142 /** 143 * @tc.name: ParseMemParseTestMutiMeasureData 144 * @tc.desc: Parse muti MemoryData object and count StatInfo 145 * @tc.type: FUNC 146 */ 147 HWTEST_F(HtraceMemParserTest, ParseMemParseTestMutiMeasureData, TestSize.Level1) 148 { 149 TS_LOGI("test16-3"); 150 HtraceMemParser* memParser = new HtraceMemParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 151 152 MemoryData tracePacket; 153 ProcessMemoryInfo* memoryInfo = tracePacket.add_processesinfo(); 154 EXPECT_TRUE(memoryInfo != nullptr); 155 int size = tracePacket.processesinfo_size(); 156 EXPECT_TRUE(size == 1); 157 uint64_t timeStamp = 1616439852302; 158 BuiltinClocks clock = TS_CLOCK_REALTIME; 159 uint32_t pid = 12; 160 memoryInfo->set_pid(12); 161 memoryInfo->set_name("Process1"); 162 memoryInfo->set_vm_size_kb(1024); 163 memoryInfo->set_vm_rss_kb(512); 164 memoryInfo->set_rss_anon_kb(128); 165 memoryInfo->set_rss_file_kb(128); 166 167 ProcessMemoryInfo* memoryInfo2 = tracePacket.add_processesinfo(); 168 EXPECT_TRUE(memoryInfo2 != nullptr); 169 size = tracePacket.processesinfo_size(); 170 EXPECT_TRUE(size == 2); 171 timeStamp = 1616439852402; 172 uint32_t pid2 = 13; 173 memoryInfo2->set_pid(pid2); 174 memoryInfo2->set_name("Process2"); 175 memoryInfo2->set_vm_size_kb(1024); 176 memoryInfo2->set_vm_rss_kb(512); 177 memoryInfo2->set_rss_anon_kb(128); 178 memoryInfo2->set_rss_file_kb(128); 179 180 memParser->Parse(tracePacket, timeStamp, clock); 181 memParser->Finish(); 182 stream_.traceDataCache_->ExportDatabase(dbPath_); 183 184 EXPECT_TRUE(access(dbPath_.c_str(), F_OK) == 0); 185 tracePacket.clear_processesinfo(); 186 delete memParser; 187 188 auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_MEMORY, STAT_EVENT_RECEIVED); 189 EXPECT_TRUE(1 == eventCount); 190 191 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessData(1).pid_ == pid); 192 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessData(2).pid_ == pid2); 193 } 194 195 /** 196 * @tc.name: ParseMultiEmptyProcessMemoryInfo 197 * @tc.desc: Parse muti Empty ProcessMemoryInfo object and count StatInfo 198 * @tc.type: FUNC 199 */ 200 HWTEST_F(HtraceMemParserTest, ParseMultiEmptyProcessMemoryInfo, TestSize.Level1) 201 { 202 TS_LOGI("test16-4"); 203 HtraceMemParser* memParser = new HtraceMemParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 204 205 MemoryData tracePacket; 206 ProcessMemoryInfo* memoryInfo = tracePacket.add_processesinfo(); 207 EXPECT_TRUE(memoryInfo != nullptr); 208 int size = tracePacket.processesinfo_size(); 209 EXPECT_TRUE(size == 1); 210 uint64_t timeStamp = 1616439852302; 211 BuiltinClocks clock = TS_CLOCK_REALTIME; 212 213 ProcessMemoryInfo* memoryInfo2 = tracePacket.add_processesinfo(); 214 EXPECT_TRUE(memoryInfo2 != nullptr); 215 size = tracePacket.processesinfo_size(); 216 EXPECT_TRUE(size == 2); 217 218 memParser->Parse(tracePacket, timeStamp, clock); 219 memParser->Finish(); 220 stream_.traceDataCache_->ExportDatabase(dbPath_); 221 222 EXPECT_TRUE(access(dbPath_.c_str(), F_OK) == 0); 223 tracePacket.clear_processesinfo(); 224 delete memParser; 225 226 auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_MEMORY, STAT_EVENT_RECEIVED); 227 EXPECT_TRUE(1 == eventCount); 228 229 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessMeasureData().Size() == MEM_MAX * 2); 230 } 231 232 /** 233 * @tc.name: ParseEmptyMemoryData 234 * @tc.desc: Parse Empty MemoryData 235 * @tc.type: FUNC 236 */ 237 HWTEST_F(HtraceMemParserTest, ParseEmptyMemoryData, TestSize.Level1) 238 { 239 TS_LOGI("test16-5"); 240 HtraceMemParser* memParser = new HtraceMemParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 241 242 MemoryData tracePacket; 243 int size = tracePacket.processesinfo_size(); 244 EXPECT_TRUE(size == 0); 245 uint64_t timeStamp = 1616439852302; 246 BuiltinClocks clock = TS_CLOCK_REALTIME; 247 248 memParser->Parse(tracePacket, timeStamp, clock); 249 memParser->Finish(); 250 delete memParser; 251 252 auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_MEMORY, STAT_EVENT_RECEIVED); 253 EXPECT_TRUE(0 == eventCount); 254 } 255 } // namespace TraceStreamer 256 } // namespace SysTuning 257