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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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, false)); 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 */ 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, 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 994 /** 995 * @tc.name: smaps_rollup stats 996 * @tc.desc: test ParseMaps 997 * @tc.type: FUNC 998 */ 999 HWTEST_F(SmapsStatsTest, TestParseSmapsrollup, TestSize.Level1) 1000 { 1001 // 3036, 4256, 288, 748, 0, 1388 1002 int pid = 2; 1003 1004 uint64_t size = 0; 1005 uint64_t rss = 4524; 1006 uint64_t pss = 1477; 1007 uint64_t dirty = 1404; 1008 uint64_t swap = 0; 1009 uint64_t swapPss = 0; 1010 uint64_t swapper = swap + swapPss; 1011 double reside = 0; 1012 uint64_t sharedClean = 2800; 1013 uint64_t sharedDirty = 380; 1014 uint64_t privateClean = 320; 1015 uint64_t privateDirty = 1024; 1016 1017 ASSERT_EQ(access(DEFAULT_TEST_PATH.c_str(), F_OK), 0); 1018 SmapsStats plugin(DEFAULT_TEST_PATH + std::string("proc/")); 1019 1020 // test result 1021 ProcessMemoryInfo processMemoryInfo; 1022 SmapsInfo* smapsInfo = nullptr; 1023 1024 ASSERT_TRUE(plugin.ParseMaps(pid, processMemoryInfo, smapsInfo, true, true, true)); 1025 EXPECT_EQ(size, processMemoryInfo.smapinfo(0).size()); 1026 EXPECT_EQ(rss, processMemoryInfo.smapinfo(0).rss()); 1027 EXPECT_EQ(pss, processMemoryInfo.smapinfo(0).pss()); 1028 EXPECT_EQ(dirty, processMemoryInfo.smapinfo(0).dirty()); 1029 EXPECT_EQ(swapper, processMemoryInfo.smapinfo(0).swapper()); 1030 EXPECT_EQ(reside, processMemoryInfo.smapinfo(0).reside()); 1031 EXPECT_EQ(swap, processMemoryInfo.smapinfo(0).swap()); 1032 EXPECT_EQ(swapPss, processMemoryInfo.smapinfo(0).swap_pss()); 1033 EXPECT_EQ(sharedClean, processMemoryInfo.smapinfo(0).shared_clean()); 1034 EXPECT_EQ(sharedDirty, processMemoryInfo.smapinfo(0).shared_dirty()); 1035 EXPECT_EQ(privateClean, processMemoryInfo.smapinfo(0).private_clean()); 1036 EXPECT_EQ(privateDirty, processMemoryInfo.smapinfo(0).private_dirty()); 1037 } 1038 1039 } // namespace