1 /*
2 * Copyright (c) Huawei Technologies Co., Ltd. 2021. All rights reserved.
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 <dlfcn.h>
17 #include <gtest/gtest.h>
18 #include "memory_data_plugin.h"
19 #include "plugin_module_api.h"
20 #include "smaps_stats.h"
21
22 using namespace testing::ext;
23
24 namespace {
25 const std::string DEFAULT_TEST_PATH("/data/local/tmp/utresources/");
26
27 class SmapsStatsTest : public ::testing::Test {
28 public:
SetUpTestCase()29 static void SetUpTestCase() {}
TearDownTestCase()30 static void TearDownTestCase()
31 {
32 if (access(DEFAULT_TEST_PATH.c_str(), F_OK) == 0) {
33 std::string str = "rm -rf " + DEFAULT_TEST_PATH;
34 system(str.c_str());
35 }
36 }
37
SetUp()38 void SetUp() {}
TearDown()39 void TearDown() {}
40 };
41
42 /**
43 * @tc.name: smaps stats
44 * @tc.desc: test ParseMapHead
45 * @tc.type: FUNC
46 */
HWTEST_F(SmapsStatsTest, TestParseMapHead1, TestSize.Level1)47 HWTEST_F(SmapsStatsTest, TestParseMapHead1, TestSize.Level1)
48 {
49 std::string line = "00400000-00409000 \n";
50 SmapsStats plugin;
51 MapPiecesInfo expectMappic = {0x00400000, 0x00409000, ""};
52 MapPiecesInfo targetMappic = {0};
53 SmapsHeadInfo expectSmapsHeadInfo = {"00400000", "00409000", "", "", -1};
54 SmapsHeadInfo smapsHeadInfo = {};
55 ASSERT_FALSE(plugin.ParseMapHead(line, targetMappic, smapsHeadInfo));
56 // test result
57 EXPECT_EQ(expectMappic.startAddr, targetMappic.startAddr);
58 EXPECT_EQ(expectMappic.endAddr, targetMappic.endAddr);
59 EXPECT_STREQ(expectMappic.name.c_str(), targetMappic.name.c_str());
60 EXPECT_STREQ(expectSmapsHeadInfo.startAddrStr.c_str(), smapsHeadInfo.startAddrStr.c_str());
61 EXPECT_STREQ(expectSmapsHeadInfo.startAddrStr.c_str(), smapsHeadInfo.startAddrStr.c_str());
62 EXPECT_STREQ(expectSmapsHeadInfo.permission.c_str(), smapsHeadInfo.permission.c_str());
63 EXPECT_STREQ(expectSmapsHeadInfo.path.c_str(), smapsHeadInfo.path.c_str());
64 EXPECT_EQ(expectSmapsHeadInfo.iNode, smapsHeadInfo.iNode);
65 }
66
67 /**
68 * @tc.name: smaps stats
69 * @tc.desc: test ParseMapHead
70 * @tc.type: FUNC
71 */
HWTEST_F(SmapsStatsTest, TestParseMapHead2, TestSize.Level1)72 HWTEST_F(SmapsStatsTest, TestParseMapHead2, TestSize.Level1)
73 {
74 std::string line = "00400000-00409000 r-xp\n";
75 SmapsStats plugin;
76 MapPiecesInfo expectMappic = {0x00400000, 0x00409000, ""};
77 MapPiecesInfo targetMappic = {0};
78 SmapsHeadInfo expectSmapsHeadInfo = {"00400000", "00409000", "", "", -1};
79 SmapsHeadInfo smapsHeadInfo = {};
80 ASSERT_FALSE(plugin.ParseMapHead(line, targetMappic, smapsHeadInfo));
81 // test result
82 EXPECT_EQ(expectMappic.startAddr, targetMappic.startAddr);
83 EXPECT_EQ(expectMappic.endAddr, targetMappic.endAddr);
84 EXPECT_STREQ(expectMappic.name.c_str(), targetMappic.name.c_str());
85 EXPECT_STREQ(expectSmapsHeadInfo.startAddrStr.c_str(), smapsHeadInfo.startAddrStr.c_str());
86 EXPECT_STREQ(expectSmapsHeadInfo.startAddrStr.c_str(), smapsHeadInfo.startAddrStr.c_str());
87 EXPECT_STREQ(expectSmapsHeadInfo.permission.c_str(), smapsHeadInfo.permission.c_str());
88 EXPECT_STREQ(expectSmapsHeadInfo.path.c_str(), smapsHeadInfo.path.c_str());
89 EXPECT_EQ(expectSmapsHeadInfo.iNode, smapsHeadInfo.iNode);
90 }
91
92 /**
93 * @tc.name: smaps stats
94 * @tc.desc: test ParseMapHead
95 * @tc.type: FUNC
96 */
HWTEST_F(SmapsStatsTest, TestParseMapHead3, TestSize.Level1)97 HWTEST_F(SmapsStatsTest, TestParseMapHead3, TestSize.Level1)
98 {
99 std::string line = "00400000-00409000 r-xp 00000000\n";
100 SmapsStats plugin;
101 MapPiecesInfo expectMappic = {0x00400000, 0x00409000, ""};
102 MapPiecesInfo targetMappic = {0};
103 SmapsHeadInfo expectSmapsHeadInfo = {"00400000", "00409000", "r-x", "", -1};
104 SmapsHeadInfo smapsHeadInfo = {};
105 ASSERT_FALSE(plugin.ParseMapHead(line, targetMappic, smapsHeadInfo));
106 // test result
107 EXPECT_EQ(expectMappic.startAddr, targetMappic.startAddr);
108 EXPECT_EQ(expectMappic.endAddr, targetMappic.endAddr);
109 EXPECT_STREQ(expectMappic.name.c_str(), targetMappic.name.c_str());
110 EXPECT_STREQ(expectSmapsHeadInfo.startAddrStr.c_str(), smapsHeadInfo.startAddrStr.c_str());
111 EXPECT_STREQ(expectSmapsHeadInfo.startAddrStr.c_str(), smapsHeadInfo.startAddrStr.c_str());
112 EXPECT_STREQ(expectSmapsHeadInfo.permission.c_str(), smapsHeadInfo.permission.c_str());
113 EXPECT_STREQ(expectSmapsHeadInfo.path.c_str(), smapsHeadInfo.path.c_str());
114 EXPECT_EQ(expectSmapsHeadInfo.iNode, smapsHeadInfo.iNode);
115 }
116
117 /**
118 * @tc.name: smaps stats
119 * @tc.desc: test ParseMapHead
120 * @tc.type: FUNC
121 */
HWTEST_F(SmapsStatsTest, TestParseMapHead4, TestSize.Level1)122 HWTEST_F(SmapsStatsTest, TestParseMapHead4, TestSize.Level1)
123 {
124 std::string line = "00400000-00409000 r-xp 00000000 fc:00\n";
125 SmapsStats plugin;
126 MapPiecesInfo expectMappic = {0x00400000, 0x00409000, ""};
127 MapPiecesInfo targetMappic = {0};
128 SmapsHeadInfo expectSmapsHeadInfo = {"00400000", "00409000", "r-x", "", -1};
129 SmapsHeadInfo smapsHeadInfo = {};
130 ASSERT_FALSE(plugin.ParseMapHead(line, targetMappic, smapsHeadInfo));
131 // test result
132 EXPECT_EQ(expectMappic.startAddr, targetMappic.startAddr);
133 EXPECT_EQ(expectMappic.endAddr, targetMappic.endAddr);
134 EXPECT_STREQ(expectMappic.name.c_str(), targetMappic.name.c_str());
135 EXPECT_STREQ(expectSmapsHeadInfo.startAddrStr.c_str(), smapsHeadInfo.startAddrStr.c_str());
136 EXPECT_STREQ(expectSmapsHeadInfo.startAddrStr.c_str(), smapsHeadInfo.startAddrStr.c_str());
137 EXPECT_STREQ(expectSmapsHeadInfo.permission.c_str(), smapsHeadInfo.permission.c_str());
138 EXPECT_STREQ(expectSmapsHeadInfo.path.c_str(), smapsHeadInfo.path.c_str());
139 EXPECT_EQ(expectSmapsHeadInfo.iNode, smapsHeadInfo.iNode);
140 }
141
142 /**
143 * @tc.name: smaps stats
144 * @tc.desc: test ParseMapHead
145 * @tc.type: FUNC
146 */
HWTEST_F(SmapsStatsTest, TestParseMapHead5, TestSize.Level1)147 HWTEST_F(SmapsStatsTest, TestParseMapHead5, TestSize.Level1)
148 {
149 std::string line = "00400000-00409000 r-xp 00000000 fc:00 426998\n";
150 SmapsStats plugin;
151 MapPiecesInfo expectMappic = {0x00400000, 0x00409000, ""};
152 MapPiecesInfo targetMappic = {0};
153 SmapsHeadInfo expectSmapsHeadInfo = {"00400000", "00409000", "r-x", "", -1};
154 SmapsHeadInfo smapsHeadInfo = {};
155 ASSERT_FALSE(plugin.ParseMapHead(line, targetMappic, smapsHeadInfo));
156 // test result
157 EXPECT_EQ(expectMappic.startAddr, targetMappic.startAddr);
158 EXPECT_EQ(expectMappic.endAddr, targetMappic.endAddr);
159 EXPECT_STREQ(expectMappic.name.c_str(), targetMappic.name.c_str());
160 EXPECT_STREQ(expectSmapsHeadInfo.startAddrStr.c_str(), smapsHeadInfo.startAddrStr.c_str());
161 EXPECT_STREQ(expectSmapsHeadInfo.startAddrStr.c_str(), smapsHeadInfo.startAddrStr.c_str());
162 EXPECT_STREQ(expectSmapsHeadInfo.permission.c_str(), smapsHeadInfo.permission.c_str());
163 EXPECT_STREQ(expectSmapsHeadInfo.path.c_str(), smapsHeadInfo.path.c_str());
164 EXPECT_EQ(expectSmapsHeadInfo.iNode, smapsHeadInfo.iNode);
165 }
166
167 /**
168 * @tc.name: smaps stats
169 * @tc.desc: test ParseMapHead
170 * @tc.type: FUNC
171 */
HWTEST_F(SmapsStatsTest, TestParseMapHead6, TestSize.Level1)172 HWTEST_F(SmapsStatsTest, TestParseMapHead6, TestSize.Level1)
173 {
174 std::string line = "00400000-00409000 r-xp 00000000 fc:00 426998 /usr/lib/gvfs/gvfsd-http\n";
175 SmapsStats plugin;
176 MapPiecesInfo expectMappic = {0x00400000, 0x00409000, "/usr/lib/gvfs/gvfsd-http"};
177 MapPiecesInfo targetMappic = {0};
178 SmapsHeadInfo expectSmapsHeadInfo = {"00400000", "00409000", "r-x", "/usr/lib/gvfs/gvfsd-http", 426998};
179 SmapsHeadInfo smapsHeadInfo = {};
180 ASSERT_TRUE(plugin.ParseMapHead(line, targetMappic, smapsHeadInfo));
181 // test result
182 EXPECT_EQ(expectMappic.startAddr, targetMappic.startAddr);
183 EXPECT_EQ(expectMappic.endAddr, targetMappic.endAddr);
184 EXPECT_STREQ(expectMappic.name.c_str(), targetMappic.name.c_str());
185 EXPECT_STREQ(expectSmapsHeadInfo.startAddrStr.c_str(), smapsHeadInfo.startAddrStr.c_str());
186 EXPECT_STREQ(expectSmapsHeadInfo.startAddrStr.c_str(), smapsHeadInfo.startAddrStr.c_str());
187 EXPECT_STREQ(expectSmapsHeadInfo.permission.c_str(), smapsHeadInfo.permission.c_str());
188 EXPECT_STREQ(expectSmapsHeadInfo.path.c_str(), smapsHeadInfo.path.c_str());
189 EXPECT_EQ(expectSmapsHeadInfo.iNode, smapsHeadInfo.iNode);
190 }
191
192 /**
193 * @tc.name: smaps stats
194 * @tc.desc: test ParseMapHead
195 * @tc.type: FUNC
196 */
HWTEST_F(SmapsStatsTest, TestParseMapHead7, TestSize.Level1)197 HWTEST_F(SmapsStatsTest, TestParseMapHead7, TestSize.Level1)
198 {
199 std::string line = "00400000-00409000 r-xp 00000000 fc:00 426998 /usr/lib/gvfs/gvfsd-http";
200 SmapsStats plugin;
201 MapPiecesInfo expectMappic = {0x00400000, 0x00409000, "/usr/lib/gvfs/gvfsd-htt"};
202 MapPiecesInfo targetMappic = {0};
203 SmapsHeadInfo expectSmapsHeadInfo = {"00400000", "00409000", "r-x", "/usr/lib/gvfs/gvfsd-htt", 426998};
204 SmapsHeadInfo smapsHeadInfo = {};
205 ASSERT_TRUE(plugin.ParseMapHead(line, targetMappic, smapsHeadInfo));
206 // test result
207 EXPECT_EQ(expectMappic.startAddr, targetMappic.startAddr);
208 EXPECT_EQ(expectMappic.endAddr, targetMappic.endAddr);
209 EXPECT_STREQ(expectMappic.name.c_str(), targetMappic.name.c_str());
210 EXPECT_STREQ(expectSmapsHeadInfo.startAddrStr.c_str(), smapsHeadInfo.startAddrStr.c_str());
211 EXPECT_STREQ(expectSmapsHeadInfo.startAddrStr.c_str(), smapsHeadInfo.startAddrStr.c_str());
212 EXPECT_STREQ(expectSmapsHeadInfo.permission.c_str(), smapsHeadInfo.permission.c_str());
213 EXPECT_STREQ(expectSmapsHeadInfo.path.c_str(), smapsHeadInfo.path.c_str());
214 EXPECT_EQ(expectSmapsHeadInfo.iNode, smapsHeadInfo.iNode);
215 }
216
217 /**
218 * @tc.name: smaps stats
219 * @tc.desc: test ParseMapHead
220 * @tc.type: FUNC
221 */
HWTEST_F(SmapsStatsTest, TestParseMapHead8, TestSize.Level1)222 HWTEST_F(SmapsStatsTest, TestParseMapHead8, TestSize.Level1)
223 {
224 std::string line = "564045dbe000-564045ddf000 rw-p 00000000 00:00 0 [heap]";
225 SmapsStats plugin;
226 MapPiecesInfo expectMappic = {0x564045dbe000, 0x564045ddf000, "[heap"};
227 MapPiecesInfo targetMappic = {0};
228 SmapsHeadInfo expectSmapsHeadInfo = {"564045dbe000", "564045ddf000", "rw-", "[heap", 0};
229 SmapsHeadInfo smapsHeadInfo = {};
230 ASSERT_TRUE(plugin.ParseMapHead(line, targetMappic, smapsHeadInfo));
231 // test result
232 EXPECT_EQ(expectMappic.startAddr, targetMappic.startAddr);
233 EXPECT_EQ(expectMappic.endAddr, targetMappic.endAddr);
234 EXPECT_STREQ(expectMappic.name.c_str(), targetMappic.name.c_str());
235 EXPECT_STREQ(expectSmapsHeadInfo.startAddrStr.c_str(), smapsHeadInfo.startAddrStr.c_str());
236 EXPECT_STREQ(expectSmapsHeadInfo.startAddrStr.c_str(), smapsHeadInfo.startAddrStr.c_str());
237 EXPECT_STREQ(expectSmapsHeadInfo.permission.c_str(), smapsHeadInfo.permission.c_str());
238 EXPECT_STREQ(expectSmapsHeadInfo.path.c_str(), smapsHeadInfo.path.c_str());
239 EXPECT_EQ(expectSmapsHeadInfo.iNode, smapsHeadInfo.iNode);
240 }
241
242 /**
243 * @tc.name: smaps stats
244 * @tc.desc: test GetMemUsageField
245 * @tc.type: FUNC
246 */
HWTEST_F(SmapsStatsTest, TestGetMemUsageField1, TestSize.Level1)247 HWTEST_F(SmapsStatsTest, TestGetMemUsageField1, TestSize.Level1)
248 {
249 std::string line = "Pss: 4 kB";
250 SmapsStats plugin;
251 MemUsageInfo expect = {0, 0, 4};
252 MemUsageInfo target = {0};
253
254 ASSERT_TRUE(plugin.GetMemUsageField(line, target));
255 // test result
256 EXPECT_EQ(expect.vss, target.vss);
257 EXPECT_EQ(expect.rss, target.rss);
258 EXPECT_EQ(expect.pss, target.pss);
259 EXPECT_EQ(expect.uss, target.uss);
260 EXPECT_EQ(expect.swap, target.swap);
261 EXPECT_EQ(expect.swapPss, target.swapPss);
262 EXPECT_EQ(expect.privateClean, target.privateClean);
263 EXPECT_EQ(expect.privateDirty, target.privateDirty);
264 EXPECT_EQ(expect.sharedClean, target.sharedClean);
265 EXPECT_EQ(expect.sharedDirty, target.sharedDirty);
266 }
267
268 /**
269 * @tc.name: smaps stats
270 * @tc.desc: test GetMemUsageField
271 * @tc.type: FUNC
272 */
HWTEST_F(SmapsStatsTest, TestGetMemUsageField2, TestSize.Level1)273 HWTEST_F(SmapsStatsTest, TestGetMemUsageField2, TestSize.Level1)
274 {
275 std::string line = "Private_Clean: 0 kB";
276 SmapsStats plugin;
277 MemUsageInfo expect = {0};
278 MemUsageInfo target = {0};
279
280 ASSERT_TRUE(plugin.GetMemUsageField(line, target));
281 // test result
282 EXPECT_EQ(expect.vss, target.vss);
283 EXPECT_EQ(expect.rss, target.rss);
284 EXPECT_EQ(expect.pss, target.pss);
285 EXPECT_EQ(expect.uss, target.uss);
286 EXPECT_EQ(expect.swap, target.swap);
287 EXPECT_EQ(expect.swapPss, target.swapPss);
288 EXPECT_EQ(expect.privateClean, target.privateClean);
289 EXPECT_EQ(expect.privateDirty, target.privateDirty);
290 EXPECT_EQ(expect.sharedClean, target.sharedClean);
291 EXPECT_EQ(expect.sharedDirty, target.sharedDirty);
292 }
293
294 /**
295 * @tc.name: smaps stats
296 * @tc.desc: test GetMemUsageField
297 * @tc.type: FUNC
298 */
HWTEST_F(SmapsStatsTest, TestGetMemUsageField3, TestSize.Level1)299 HWTEST_F(SmapsStatsTest, TestGetMemUsageField3, TestSize.Level1)
300 {
301 std::string line = "Private_Dirty: 4 kB";
302 SmapsStats plugin;
303 uint64_t num = 4;
304 MemUsageInfo expect = {0};
305 MemUsageInfo target = {0};
306
307 ASSERT_TRUE(plugin.GetMemUsageField(line, target));
308 // test result
309 expect.privateDirty = num;
310 expect.uss += num;
311 EXPECT_EQ(expect.vss, target.vss);
312 EXPECT_EQ(expect.rss, target.rss);
313 EXPECT_EQ(expect.pss, target.pss);
314 EXPECT_EQ(expect.uss, target.uss);
315 EXPECT_EQ(expect.swap, target.swap);
316 EXPECT_EQ(expect.swapPss, target.swapPss);
317 EXPECT_EQ(expect.privateClean, target.privateClean);
318 EXPECT_EQ(expect.privateDirty, target.privateDirty);
319 EXPECT_EQ(expect.sharedClean, target.sharedClean);
320 EXPECT_EQ(expect.sharedDirty, target.sharedDirty);
321 }
322
323 /**
324 * @tc.name: smaps stats
325 * @tc.desc: test GetMemUsageField
326 * @tc.type: FUNC
327 */
HWTEST_F(SmapsStatsTest, TestGetMemUsageField4, TestSize.Level1)328 HWTEST_F(SmapsStatsTest, TestGetMemUsageField4, TestSize.Level1)
329 {
330 std::string line = "Size: 4 kB";
331 SmapsStats plugin;
332 uint64_t num = 4;
333 MemUsageInfo expect = {0};
334 MemUsageInfo target = {0};
335
336 ASSERT_TRUE(plugin.GetMemUsageField(line, target));
337 // test result
338 expect.vss = num;
339 EXPECT_EQ(expect.vss, target.vss);
340 EXPECT_EQ(expect.rss, target.rss);
341 EXPECT_EQ(expect.pss, target.pss);
342 EXPECT_EQ(expect.uss, target.uss);
343 EXPECT_EQ(expect.swap, target.swap);
344 EXPECT_EQ(expect.swapPss, target.swapPss);
345 EXPECT_EQ(expect.privateClean, target.privateClean);
346 EXPECT_EQ(expect.privateDirty, target.privateDirty);
347 EXPECT_EQ(expect.sharedClean, target.sharedClean);
348 EXPECT_EQ(expect.sharedDirty, target.sharedDirty);
349 }
350
351 /**
352 * @tc.name: smaps stats
353 * @tc.desc: test GetMemUsageField
354 * @tc.type: FUNC
355 */
HWTEST_F(SmapsStatsTest, TestGetMemUsageField5, TestSize.Level1)356 HWTEST_F(SmapsStatsTest, TestGetMemUsageField5, TestSize.Level1)
357 {
358 std::string line = "Shared_Clean: 0 kB";
359 SmapsStats plugin;
360 MemUsageInfo expect = {0};
361 MemUsageInfo target = {0};
362
363 ASSERT_TRUE(plugin.GetMemUsageField(line, target));
364 // test result
365 EXPECT_EQ(expect.vss, target.vss);
366 EXPECT_EQ(expect.rss, target.rss);
367 EXPECT_EQ(expect.pss, target.pss);
368 EXPECT_EQ(expect.uss, target.uss);
369 EXPECT_EQ(expect.swap, target.swap);
370 EXPECT_EQ(expect.swapPss, target.swapPss);
371 EXPECT_EQ(expect.privateClean, target.privateClean);
372 EXPECT_EQ(expect.privateDirty, target.privateDirty);
373 EXPECT_EQ(expect.sharedClean, target.sharedClean);
374 EXPECT_EQ(expect.sharedDirty, target.sharedDirty);
375 }
376
377 /**
378 * @tc.name: smaps stats
379 * @tc.desc: test GetMemUsageField
380 * @tc.type: FUNC
381 */
HWTEST_F(SmapsStatsTest, TestGetMemUsageField6, TestSize.Level1)382 HWTEST_F(SmapsStatsTest, TestGetMemUsageField6, TestSize.Level1)
383 {
384 std::string line = "Shared_Dirty: 0 kB";
385 SmapsStats plugin;
386 MemUsageInfo expect = {0};
387 MemUsageInfo target = {0};
388
389 ASSERT_TRUE(plugin.GetMemUsageField(line, target));
390 // test result
391 EXPECT_EQ(expect.vss, target.vss);
392 EXPECT_EQ(expect.rss, target.rss);
393 EXPECT_EQ(expect.pss, target.pss);
394 EXPECT_EQ(expect.uss, target.uss);
395 EXPECT_EQ(expect.swap, target.swap);
396 EXPECT_EQ(expect.swapPss, target.swapPss);
397 EXPECT_EQ(expect.privateClean, target.privateClean);
398 EXPECT_EQ(expect.privateDirty, target.privateDirty);
399 EXPECT_EQ(expect.sharedClean, target.sharedClean);
400 EXPECT_EQ(expect.sharedDirty, target.sharedDirty);
401 }
402
403 /**
404 * @tc.name: smaps stats
405 * @tc.desc: test GetMemUsageField
406 * @tc.type: FUNC
407 */
HWTEST_F(SmapsStatsTest, TestGetMemUsageField7, TestSize.Level1)408 HWTEST_F(SmapsStatsTest, TestGetMemUsageField7, TestSize.Level1)
409 {
410 std::string line = "Swap: 0 kB";
411 SmapsStats plugin;
412 MemUsageInfo expect = {0};
413 MemUsageInfo target = {0};
414
415 ASSERT_TRUE(plugin.GetMemUsageField(line, target));
416 // test result
417 EXPECT_EQ(expect.vss, target.vss);
418 EXPECT_EQ(expect.rss, target.rss);
419 EXPECT_EQ(expect.pss, target.pss);
420 EXPECT_EQ(expect.uss, target.uss);
421 EXPECT_EQ(expect.swap, target.swap);
422 EXPECT_EQ(expect.swapPss, target.swapPss);
423 EXPECT_EQ(expect.privateClean, target.privateClean);
424 EXPECT_EQ(expect.privateDirty, target.privateDirty);
425 EXPECT_EQ(expect.sharedClean, target.sharedClean);
426 EXPECT_EQ(expect.sharedDirty, target.sharedDirty);
427 }
428
429 /**
430 * @tc.name: smaps stats
431 * @tc.desc: test GetMemUsageField
432 * @tc.type: FUNC
433 */
HWTEST_F(SmapsStatsTest, TestGetMemUsageField8, TestSize.Level1)434 HWTEST_F(SmapsStatsTest, TestGetMemUsageField8, TestSize.Level1)
435 {
436 std::string line = "SwapPss: 0 kB";
437 SmapsStats plugin;
438 MemUsageInfo expect = {0};
439 MemUsageInfo target = {0};
440
441 ASSERT_TRUE(plugin.GetMemUsageField(line, target));
442 // test result
443 EXPECT_EQ(expect.vss, target.vss);
444 EXPECT_EQ(expect.rss, target.rss);
445 EXPECT_EQ(expect.pss, target.pss);
446 EXPECT_EQ(expect.uss, target.uss);
447 EXPECT_EQ(expect.swap, target.swap);
448 EXPECT_EQ(expect.swapPss, target.swapPss);
449 EXPECT_EQ(expect.privateClean, target.privateClean);
450 EXPECT_EQ(expect.privateDirty, target.privateDirty);
451 EXPECT_EQ(expect.sharedClean, target.sharedClean);
452 EXPECT_EQ(expect.sharedDirty, target.sharedDirty);
453 }
454
455 /**
456 * @tc.name: smaps stats
457 * @tc.desc: test GetMemUsageField
458 * @tc.type: FUNC
459 */
HWTEST_F(SmapsStatsTest, TestGetMemUsageField9, TestSize.Level1)460 HWTEST_F(SmapsStatsTest, TestGetMemUsageField9, TestSize.Level1)
461 {
462 std::string line = "Rss: 4 kB";
463 SmapsStats plugin;
464 uint64_t num = 4;
465 MemUsageInfo expect = {0};
466 MemUsageInfo target = {0};
467
468 ASSERT_TRUE(plugin.GetMemUsageField(line, target));
469 // test result
470 expect.rss = num;
471 EXPECT_EQ(expect.vss, target.vss);
472 EXPECT_EQ(expect.rss, target.rss);
473 EXPECT_EQ(expect.pss, target.pss);
474 EXPECT_EQ(expect.uss, target.uss);
475 EXPECT_EQ(expect.swap, target.swap);
476 EXPECT_EQ(expect.swapPss, target.swapPss);
477 EXPECT_EQ(expect.privateClean, target.privateClean);
478 EXPECT_EQ(expect.privateDirty, target.privateDirty);
479 EXPECT_EQ(expect.sharedClean, target.sharedClean);
480 EXPECT_EQ(expect.sharedDirty, target.sharedDirty);
481 }
482
483 /**
484 * @tc.name: smaps stats
485 * @tc.desc: test GetMemUsageField
486 * @tc.type: FUNC
487 */
HWTEST_F(SmapsStatsTest, TestGetMemUsageField10, TestSize.Level1)488 HWTEST_F(SmapsStatsTest, TestGetMemUsageField10, TestSize.Level1)
489 {
490 std::string line = "VmFlags: rd ex mr mw me dw sd";
491 SmapsStats plugin;
492 MemUsageInfo expect = {0};
493 MemUsageInfo target = {0};
494
495 ASSERT_TRUE(plugin.GetMemUsageField(line, target));
496 // test result
497 EXPECT_EQ(expect.vss, target.vss);
498 EXPECT_EQ(expect.rss, target.rss);
499 EXPECT_EQ(expect.pss, target.pss);
500 EXPECT_EQ(expect.uss, target.uss);
501 EXPECT_EQ(expect.swap, target.swap);
502 EXPECT_EQ(expect.swapPss, target.swapPss);
503 EXPECT_EQ(expect.privateClean, target.privateClean);
504 EXPECT_EQ(expect.privateDirty, target.privateDirty);
505 EXPECT_EQ(expect.sharedClean, target.sharedClean);
506 EXPECT_EQ(expect.sharedDirty, target.sharedDirty);
507 }
508
509 /**
510 * @tc.name: smaps stats
511 * @tc.desc: test GetMemUsageField
512 * @tc.type: FUNC
513 */
HWTEST_F(SmapsStatsTest, TestGetMemUsageField11, TestSize.Level1)514 HWTEST_F(SmapsStatsTest, TestGetMemUsageField11, TestSize.Level1)
515 {
516 std::string line = "Anonymous: 0 kB";
517 SmapsStats plugin;
518 MemUsageInfo expect = {0};
519 MemUsageInfo target = {0};
520
521 ASSERT_TRUE(plugin.GetMemUsageField(line, target));
522 // test result
523 EXPECT_EQ(expect.vss, target.vss);
524 EXPECT_EQ(expect.rss, target.rss);
525 EXPECT_EQ(expect.pss, target.pss);
526 EXPECT_EQ(expect.uss, target.uss);
527 EXPECT_EQ(expect.swap, target.swap);
528 EXPECT_EQ(expect.swapPss, target.swapPss);
529 EXPECT_EQ(expect.privateClean, target.privateClean);
530 EXPECT_EQ(expect.privateDirty, target.privateDirty);
531 EXPECT_EQ(expect.sharedClean, target.sharedClean);
532 EXPECT_EQ(expect.sharedDirty, target.sharedDirty);
533 }
534
535 /**
536 * @tc.name: smaps stats
537 * @tc.desc: test GetMemUsageField
538 * @tc.type: FUNC
539 */
HWTEST_F(SmapsStatsTest, TestAbnormalGetMemUsageField1, TestSize.Level1)540 HWTEST_F(SmapsStatsTest, TestAbnormalGetMemUsageField1, TestSize.Level1)
541 {
542 std::string line = "Pss:";
543 SmapsStats plugin;
544 MemUsageInfo expect = {0};
545 MemUsageInfo target = {0};
546
547 ASSERT_TRUE(plugin.GetMemUsageField(line, target));
548 // test result
549 EXPECT_EQ(expect.vss, target.vss);
550 EXPECT_EQ(expect.rss, target.rss);
551 EXPECT_EQ(expect.pss, target.pss);
552 EXPECT_EQ(expect.uss, target.uss);
553 EXPECT_EQ(expect.swap, target.swap);
554 EXPECT_EQ(expect.swapPss, target.swapPss);
555 EXPECT_EQ(expect.privateClean, target.privateClean);
556 EXPECT_EQ(expect.privateDirty, target.privateDirty);
557 EXPECT_EQ(expect.sharedClean, target.sharedClean);
558 EXPECT_EQ(expect.sharedDirty, target.sharedDirty);
559 }
560
561 /**
562 * @tc.name: smaps stats
563 * @tc.desc: test GetMemUsageField
564 * @tc.type: FUNC
565 */
HWTEST_F(SmapsStatsTest, TestAbnormalGetMemUsageField2, TestSize.Level1)566 HWTEST_F(SmapsStatsTest, TestAbnormalGetMemUsageField2, TestSize.Level1)
567 {
568 std::string line = "Pss";
569 SmapsStats plugin;
570 MemUsageInfo expect = {0};
571 MemUsageInfo target = {0};
572
573 ASSERT_FALSE(plugin.GetMemUsageField(line, target));
574 // test result
575 EXPECT_EQ(expect.vss, target.vss);
576 EXPECT_EQ(expect.rss, target.rss);
577 EXPECT_EQ(expect.pss, target.pss);
578 EXPECT_EQ(expect.uss, target.uss);
579 EXPECT_EQ(expect.swap, target.swap);
580 EXPECT_EQ(expect.swapPss, target.swapPss);
581 EXPECT_EQ(expect.privateClean, target.privateClean);
582 EXPECT_EQ(expect.privateDirty, target.privateDirty);
583 EXPECT_EQ(expect.sharedClean, target.sharedClean);
584 EXPECT_EQ(expect.sharedDirty, target.sharedDirty);
585 }
586
587 namespace {
588 const char* SMAPS_FORMAT = R"(5637ebe15000-5637ebe16000 r-xp 00000000 08:01 4587541 test/run
589 Size: 4 kB
590 Rss: 4 kB
591 Pss: 4 kB
592 Shared_Clean: 0 kB
593 Shared_Dirty: 0 kB
594 Private_Clean: 4 kB
595 Private_Dirty: 0 kB
596 Anonymous: 0 kB
597 Swap: 0 kB
598 SwapPss: 0 kB
599 LazyFree: 1 kB
600 AnonHugePages: 1 kB
601 ShmemPmdMapped: 1 kB
602 FilePmdMapped: 1 kB
603 Shared_Hugetlb: 1 kB
604 Private_Hugetlb: 1 kB
605 Locked: 1 kB
606 THPeligible: 1
607 VmFlags: rd ex mr mw me dw sd
608 5637ec015000-5637ec016000 r--p 00000000 08:01 4587541 test/run
609 Size: 4 kB
610 Rss: 4 kB
611 Pss: 4 kB
612 Shared_Clean: 0 kB
613 Shared_Dirty: 0 kB
614 Private_Clean: 0 kB
615 Private_Dirty: 4 kB
616 Anonymous: 4 kB
617 Swap: 0 kB
618 SwapPss: 0 kB
619 VmFlags: rd mr mw me dw ac sd
620 5637ec016000-5637ec017000 rw-p 00001000 08:01 4587541 test/run
621 Size: 4 kB
622 Rss: 4 kB
623 Pss: 4 kB
624 Shared_Clean: 0 kB
625 Shared_Dirty: 0 kB
626 Private_Clean: 0 kB
627 Private_Dirty: 4 kB
628 Anonymous: 4 kB
629 Swap: 0 kB
630 SwapPss: 0 kB
631 VmFlags: rd wr mr mw me dw ac sd
632 5637ec60f000-5637ec630000 rw-p 00000000 00:00 0 [heap]
633 Size: 132 kB
634 Rss: 4 kB
635 Pss: 4 kB
636 Shared_Clean: 0 kB
637 Shared_Dirty: 0 kB
638 Private_Clean: 0 kB
639 Private_Dirty: 4 kB
640 Anonymous: 4 kB
641 Swap: 0 kB
642 SwapPss: 0 kB
643 VmFlags: rd wr mr mw me ac sd
644 7fa384a9e000-7fa384c85000 r-xp 00000000 08:01 929310 /lib/x86_64-linux-gnu/libc-2.27.so
645 Size: 1948 kB
646 Rss: 1200 kB
647 Pss: 20 kB
648 Shared_Clean: 1200 kB
649 Shared_Dirty: 0 kB
650 Private_Clean: 0 kB
651 Private_Dirty: 0 kB
652 Anonymous: 0 kB
653 Swap: 0 kB
654 SwapPss: 0 kB
655 VmFlags: rd ex mr mw me sd
656 7fa384c85000-7fa384e85000 ---p 001e7000 08:01 929310 /lib/x86_64-linux-gnu/libc-2.27.so
657 Size: 2048 kB
658 Rss: 0 kB
659 Pss: 0 kB
660 Shared_Clean: 0 kB
661 Shared_Dirty: 0 kB
662 Private_Clean: 0 kB
663 Private_Dirty: 0 kB
664 Anonymous: 0 kB
665 Swap: 0 kB
666 SwapPss: 0 kB
667 VmFlags: mr mw me sd
668 7fa384e85000-7fa384e89000 r--p 001e7000 08:01 929310 /lib/x86_64-linux-gnu/libc-2.27.so
669 Size: 16 kB
670 Rss: 16 kB
671 Pss: 16 kB
672 Shared_Clean: 0 kB
673 Shared_Dirty: 0 kB
674 Private_Clean: 0 kB
675 Private_Dirty: 16 kB
676 Anonymous: 16 kB
677 Swap: 0 kB
678 SwapPss: 0 kB
679 VmFlags: rd mr mw me ac sd
680 7fa384e89000-7fa384e8b000 rw-p 001eb000 08:01 929310 /lib/x86_64-linux-gnu/libc-2.27.so
681 Size: 8 kB
682 Rss: 8 kB
683 Pss: 8 kB
684 Shared_Clean: 0 kB
685 Shared_Dirty: 0 kB
686 Private_Clean: 0 kB
687 Private_Dirty: 8 kB
688 Anonymous: 8 kB
689 Swap: 0 kB
690 SwapPss: 0 kB
691 VmFlags: rd wr mr mw me ac sd
692 7fa384e8b000-7fa384e8f000 rw-p 00000000 00:00 0
693 Size: 16 kB
694 Rss: 12 kB
695 Pss: 12 kB
696 Shared_Clean: 0 kB
697 Shared_Dirty: 0 kB
698 Private_Clean: 0 kB
699 Private_Dirty: 12 kB
700 Anonymous: 12 kB
701 Swap: 0 kB
702 SwapPss: 0 kB
703 VmFlags: rd wr mr mw me ac sd
704 7fa384e8f000-7fa384eb8000 r-xp 00000000 08:01 927476 /lib/x86_64-linux-gnu/ld-2.27.so
705 Size: 164 kB
706 Rss: 164 kB
707 Pss: 3 kB
708 Shared_Clean: 164 kB
709 Shared_Dirty: 0 kB
710 Private_Clean: 0 kB
711 Private_Dirty: 0 kB
712 Anonymous: 0 kB
713 Swap: 0 kB
714 SwapPss: 0 kB
715 VmFlags: rd ex mr mw me dw sd
716 7fa3850a1000-7fa3850a3000 rw-p 00000000 00:00 0
717 Size: 8 kB
718 Rss: 8 kB
719 Pss: 8 kB
720 Shared_Clean: 0 kB
721 Shared_Dirty: 0 kB
722 Private_Clean: 0 kB
723 Private_Dirty: 8 kB
724 Anonymous: 8 kB
725 Swap: 0 kB
726 SwapPss: 0 kB
727 VmFlags: rd wr mr mw me ac sd
728 7fa3850b8000-7fa3850b9000 r--p 00029000 08:01 927476 /lib/x86_64-linux-gnu/ld-2.27.so
729 Size: 4 kB
730 Rss: 4 kB
731 Pss: 4 kB
732 Shared_Clean: 0 kB
733 Shared_Dirty: 0 kB
734 Private_Clean: 0 kB
735 Private_Dirty: 4 kB
736 Anonymous: 4 kB
737 Swap: 0 kB
738 SwapPss: 0 kB
739 VmFlags: rd mr mw me dw ac sd
740 7fa3850b9000-7fa3850ba000 rw-p 0002a000 08:01 927476 /lib/x86_64-linux-gnu/ld-2.27.so
741 Size: 4 kB
742 Rss: 4 kB
743 Pss: 4 kB
744 Shared_Clean: 0 kB
745 Shared_Dirty: 0 kB
746 Private_Clean: 0 kB
747 Private_Dirty: 4 kB
748 Anonymous: 4 kB
749 Swap: 0 kB
750 SwapPss: 0 kB
751 VmFlags: rd wr mr mw me dw ac sd
752 7fa3850ba000-7fa3850bb000 rw-p 00000000 00:00 0
753 Size: 4 kB
754 Rss: 4 kB
755 Pss: 4 kB
756 Shared_Clean: 0 kB
757 Shared_Dirty: 0 kB
758 Private_Clean: 0 kB
759 Private_Dirty: 4 kB
760 Anonymous: 4 kB
761 Swap: 0 kB
762 SwapPss: 0 kB
763 VmFlags: rd wr mr mw me ac sd
764 7ffc54ec0000-7ffc54ee1000 rw-p 00000000 00:00 0 [stack]
765 Size: 132 kB
766 Rss: 12 kB
767 Pss: 12 kB
768 Shared_Clean: 0 kB
769 Shared_Dirty: 0 kB
770 Private_Clean: 0 kB
771 Private_Dirty: 12 kB
772 Anonymous: 12 kB
773 Swap: 0 kB
774 SwapPss: 0 kB
775 VmFlags: rd wr mr mw me gd ac
776 7ffc54f1c000-7ffc54f1f000 r--p 00000000 00:00 0 [vvar]
777 Size: 12 kB
778 Rss: 0 kB
779 Pss: 0 kB
780 Shared_Clean: 0 kB
781 Shared_Dirty: 0 kB
782 Private_Clean: 0 kB
783 Private_Dirty: 0 kB
784 Anonymous: 0 kB
785 Swap: 0 kB
786 SwapPss: 0 kB
787 VmFlags: rd mr pf io de dd sd
788 7ffc54f1f000-7ffc54f20000 r-xp 00000000 00:00 0 [vdso]
789 Size: 4 kB
790 Rss: 4 kB
791 Pss: 0 kB
792 Shared_Clean: 4 kB
793 Shared_Dirty: 0 kB
794 Private_Clean: 0 kB
795 Private_Dirty: 0 kB
796 Anonymous: 0 kB
797 Swap: 0 kB
798 SwapPss: 0 kB
799 VmFlags: rd ex mr mw me de sd
800 ffffffffff600000-ffffffffff601000 --xp 00000000 00:00 0 [vsyscall]
801 Size: 4 kB
802 MMUPageSize: 4 kB
803 Rss: 0 kB
804 Pss: 0 kB
805 Shared_Clean: 0 kB
806 Shared_Dirty: 0 kB
807 Private_Clean: 0 kB
808 Private_Dirty: 0 kB
809 Anonymous: 0 kB
810 Swap: 0 kB
811 SwapPss: 0 kB
812 VmFlags: ex)";
813 }
814
815 /**
816 * @tc.name: smaps stats
817 * @tc.desc: test ReadVmemareasFile
818 * @tc.type: FUNC
819 */
HWTEST_F(SmapsStatsTest, TestFramework, TestSize.Level1)820 HWTEST_F(SmapsStatsTest, TestFramework, TestSize.Level1)
821 {
822 bool findMapHead = false;
823 MapPiecesInfo mappic = {0};
824 MemUsageInfo memusage = {0};
825 SmapsHeadInfo smapsHeadInfo = {};
826 // 3036, 4256, 288, 748, 0, 1388
827 uint64_t prevEnd = 0;
828 int prevHeap = 0;
829 uint64_t java_heap = 0;
830 uint64_t native_heap = 4;
831 uint64_t code = 48;
832 uint64_t stack = 12;
833 uint64_t graphics = 0;
834 uint64_t private_other = 20;
835 SmapsStats plugin;
836 std::istringstream ss(SMAPS_FORMAT);
837 std::string line;
838
839 while (std::getline(ss, line)) {
840 line += '\n';
841 if (!findMapHead) {
842 ASSERT_TRUE(plugin.ParseMapHead(line, mappic, smapsHeadInfo));
843 findMapHead = true;
844 continue;
845 }
846 if (findMapHead) {
847 if (line.substr(0, strlen("VmFlags:")) != std::string("VmFlags:")) {
848 ASSERT_TRUE(plugin.GetMemUsageField(line, memusage));
849 continue;
850 }
851 }
852 plugin.CollectVmemAreasData(mappic, memusage, prevEnd, prevHeap);
853 findMapHead = false;
854 }
855 plugin.ReviseStatsData();
856
857 // test result
858 EXPECT_EQ(java_heap, (uint64_t)(plugin.GetProcessJavaHeap()));
859 EXPECT_EQ(native_heap, (uint64_t)(plugin.GetProcessNativeHeap()));
860 EXPECT_EQ(code, (uint64_t)(plugin.GetProcessCode()));
861 EXPECT_EQ(stack, (uint64_t)(plugin.GetProcessStack()));
862 EXPECT_EQ(graphics, (uint64_t)(plugin.GetProcessGraphics()));
863 EXPECT_EQ(private_other, (uint64_t)(plugin.GetProcessPrivateOther()));
864 }
865
866 /**
867 * @tc.name: smaps stats
868 * @tc.desc: test ParseMaps
869 * @tc.type: FUNC
870 */
HWTEST_F(SmapsStatsTest, TestFrameworkForPath, TestSize.Level1)871 HWTEST_F(SmapsStatsTest, TestFrameworkForPath, TestSize.Level1)
872 {
873 // 3036, 4256, 288, 748, 0, 1388
874 int pid = 2;
875 uint64_t java_heap = 0;
876 uint64_t native_heap = 4;
877 uint64_t code = 48;
878 uint64_t stack = 12;
879 uint64_t graphics = 0;
880 uint64_t private_other = 20;
881
882 uint64_t size = 4;
883 uint64_t rss = 4;
884 uint64_t pss = 4;
885 uint64_t dirty = 0;
886 uint64_t swap1 = 1;
887 uint64_t swapPss1 = 2;
888 uint64_t swapper1 = swap1 + swapPss1;
889 uint64_t swap2 = 11152;
890 uint64_t swapPss2 = 10800;
891 uint64_t swapper2 = swap2 + swapPss2;
892 double reside = static_cast<double>(rss) / size * PERCENT;
893 uint64_t dirty2 = 4;
894 uint64_t sharedClean1 = 0;
895 uint64_t sharedDirty1 = 0;
896 uint64_t privateClean1 = 4;
897 uint64_t privateDirty1 = 0;
898 uint64_t sharedClean2 = 0;
899 uint64_t sharedDirty2 = 0;
900 uint64_t privateClean2 = 0;
901 uint64_t privateDirty2 = 4;
902
903 ASSERT_EQ(access(DEFAULT_TEST_PATH.c_str(), F_OK), 0);
904 SmapsStats plugin(DEFAULT_TEST_PATH + std::string("proc/"));
905
906 // test result
907 ProcessMemoryInfo processMemoryInfo;
908 SmapsInfo* smapsInfo = nullptr;
909 ASSERT_TRUE(plugin.ParseMaps(pid, processMemoryInfo, smapsInfo, true, true));
910 EXPECT_EQ(java_heap, (uint64_t)(plugin.GetProcessJavaHeap()));
911 EXPECT_EQ(native_heap, (uint64_t)(plugin.GetProcessNativeHeap()));
912 EXPECT_EQ(code, (uint64_t)(plugin.GetProcessCode()));
913 EXPECT_EQ(stack, (uint64_t)(plugin.GetProcessStack()));
914 EXPECT_EQ(graphics, (uint64_t)(plugin.GetProcessGraphics()));
915 EXPECT_EQ(private_other, (uint64_t)(plugin.GetProcessPrivateOther()));
916
917 EXPECT_EQ(size, processMemoryInfo.smapinfo(0).size());
918 EXPECT_EQ(rss, processMemoryInfo.smapinfo(0).rss());
919 EXPECT_EQ(pss, processMemoryInfo.smapinfo(0).pss());
920 EXPECT_EQ(dirty, processMemoryInfo.smapinfo(0).dirty());
921 EXPECT_EQ(swapper1, processMemoryInfo.smapinfo(0).swapper());
922 EXPECT_EQ(reside, processMemoryInfo.smapinfo(0).reside());
923 EXPECT_EQ(swap1, processMemoryInfo.smapinfo(0).swap());
924 EXPECT_EQ(swapPss1, processMemoryInfo.smapinfo(0).swap_pss());
925 EXPECT_EQ(sharedClean1, processMemoryInfo.smapinfo(0).shared_clean());
926 EXPECT_EQ(sharedDirty1, processMemoryInfo.smapinfo(0).shared_dirty());
927 EXPECT_EQ(privateClean1, processMemoryInfo.smapinfo(0).private_clean());
928 EXPECT_EQ(privateDirty1, processMemoryInfo.smapinfo(0).private_dirty());
929 EXPECT_EQ(size, processMemoryInfo.smapinfo(1).size());
930 EXPECT_EQ(rss, processMemoryInfo.smapinfo(1).rss());
931 EXPECT_EQ(pss, processMemoryInfo.smapinfo(1).pss());
932 EXPECT_EQ(dirty2, processMemoryInfo.smapinfo(1).dirty());
933 EXPECT_EQ(swapper2, processMemoryInfo.smapinfo(1).swapper());
934 EXPECT_EQ(reside, processMemoryInfo.smapinfo(1).reside());
935 EXPECT_EQ(swap2, processMemoryInfo.smapinfo(1).swap());
936 EXPECT_EQ(swapPss2, processMemoryInfo.smapinfo(1).swap_pss());
937 EXPECT_EQ(sharedClean2, processMemoryInfo.smapinfo(1).shared_clean());
938 EXPECT_EQ(sharedDirty2, processMemoryInfo.smapinfo(1).shared_dirty());
939 EXPECT_EQ(privateClean2, processMemoryInfo.smapinfo(1).private_clean());
940 EXPECT_EQ(privateDirty2, processMemoryInfo.smapinfo(1).private_dirty());
941 }
942
943 /**
944 * @tc.name: smaps stats
945 * @tc.desc: test check framework
946 * @tc.type: FUNC
947 */
HWTEST_F(SmapsStatsTest, TestCheckFramework, TestSize.Level1)948 HWTEST_F(SmapsStatsTest, TestCheckFramework, TestSize.Level1)
949 {
950 bool findMapHead = false;
951 MapPiecesInfo mappic = {0};
952 MemUsageInfo memusage = {0};
953 SmapsHeadInfo smapsHeadInfo = {};
954 uint64_t prevEnd = 0;
955 int prevHeap = 0;
956 SmapsStats testPlugin;
957 int pid = 2;
958 std::istringstream ss(SMAPS_FORMAT);
959 std::string line;
960
961 while (std::getline(ss, line)) {
962 line += '\n';
963 if (!findMapHead) {
964 ASSERT_TRUE(testPlugin.ParseMapHead(line, mappic, smapsHeadInfo));
965 findMapHead = true;
966 continue;
967 }
968 if (findMapHead) {
969 if (line.substr(0, strlen("VmFlags:")) != std::string("VmFlags:")) {
970 ASSERT_TRUE(testPlugin.GetMemUsageField(line, memusage));
971 continue;
972 }
973 }
974 testPlugin.CollectVmemAreasData(mappic, memusage, prevEnd, prevHeap);
975 findMapHead = false;
976 }
977 testPlugin.ReviseStatsData();
978
979 ASSERT_EQ(access(DEFAULT_TEST_PATH.c_str(), F_OK), 0);
980 SmapsStats targetPlugin(DEFAULT_TEST_PATH + std::string("proc/"));
981 ProcessMemoryInfo processMemoryInfo;
982 SmapsInfo* smapsInfo = nullptr;
983 ASSERT_TRUE(targetPlugin.ParseMaps(pid, processMemoryInfo, smapsInfo, true, false));
984
985 // test result
986 EXPECT_EQ(testPlugin.GetProcessJavaHeap(), targetPlugin.GetProcessJavaHeap());
987 EXPECT_EQ(testPlugin.GetProcessNativeHeap(), targetPlugin.GetProcessNativeHeap());
988 EXPECT_EQ(testPlugin.GetProcessCode(), targetPlugin.GetProcessCode());
989 EXPECT_EQ(testPlugin.GetProcessStack(), targetPlugin.GetProcessStack());
990 EXPECT_EQ(testPlugin.GetProcessGraphics(), targetPlugin.GetProcessGraphics());
991 EXPECT_EQ(testPlugin.GetProcessPrivateOther(), targetPlugin.GetProcessPrivateOther());
992 }
993 } // namespace