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