1/* 2 * Copyright (c) 2023 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 <fstream> 17#include <gtest/gtest.h> 18#include <securec.h> 19#include <string> 20#include <thread> 21#include <unistd.h> 22#include <vector> 23 24#include "dfx_dump_catcher.h" 25#include "dfx_test_util.h" 26#include "file_util.h" 27#include "procinfo.h" 28 29using namespace testing::ext; 30using namespace std; 31 32namespace OHOS { 33namespace HiviewDFX { 34class DumpCatcherSystemTest : public testing::Test { 35public: 36 static void SetUpTestCase(void); 37 static void TearDownTestCase(void); 38 void SetUp(); 39 void TearDown(); 40}; 41 42void DumpCatcherSystemTest::SetUpTestCase(void) 43{ 44 chmod("/data/crasher_c", 0755); // 0755 : -rwxr-xr-x 45 chmod("/data/crasher_cpp", 0755); // 0755 : -rwxr-xr-x 46} 47 48void DumpCatcherSystemTest::TearDownTestCase(void) 49{ 50} 51 52void DumpCatcherSystemTest::SetUp(void) 53{ 54} 55 56void DumpCatcherSystemTest::TearDown(void) 57{ 58} 59 60namespace { 61static const int ROOT_UID = 0; 62static const int BMS_UID = 1000; 63static const int OTHER_UID = 10000; 64 65static const int MULTITHREAD_TEST_COUNT = 50; 66static const int ARRAY_SIZE = 100; 67static pid_t g_rootTid[ARRAY_SIZE] = { -1 }; 68static pid_t g_appTid[ARRAY_SIZE] = { -1 }; 69static pid_t g_sysTid[ARRAY_SIZE] = { -1 }; 70 71static pid_t g_loopSysPid = 0; 72static pid_t g_loopRootPid = 0; 73static pid_t g_loopCppPid = 0; 74static pid_t g_loopAppPid = 0; 75static unsigned int g_unsignedLoopSysPid = 0; 76static int g_checkCnt = 0; 77 78enum CrasherRunType { 79 ROOT, // rus as root uid 80 SYSTEM, // run as system uid 81 APP_CRASHER_C, // crasher_c run as app uid 82 APP_CRASHER_CPP // crasher_cpp run as app uid 83}; 84} 85 86static string GetPidMax() 87{ 88 const string defaultPidMax = "32768"; // 32768 pid max 89 const string path = "/proc/sys/kernel/pid_max"; 90 string pidMax = defaultPidMax; 91 OHOS::HiviewDFX::LoadStringFromFile(path, pidMax); 92 return pidMax; 93} 94 95static string GetTidMax() 96{ 97 const string defaultTidMax = "8825"; // 8825 tid max 98 const string path = "/proc/sys/kernel/threads-max"; 99 string tidMax = defaultTidMax; 100 OHOS::HiviewDFX::LoadStringFromFile(path, tidMax); 101 return tidMax; 102} 103 104static void GetCrasherThreads(const int pid, const int uid) 105{ 106 if (pid <= 0) { 107 return; 108 } 109 110 usleep(5); // 5 : sleep 5us 111 std::vector<int> tids; 112 if (!GetTidsByPidWithFunc(pid, tids, nullptr)) { 113 return; 114 } 115 for (size_t i = 0; i < tids.size(); ++i) { 116 if (uid == ROOT_UID) { 117 g_rootTid[i] = tids[i]; 118 } else if (uid == BMS_UID) { 119 g_sysTid[i] = tids[i]; 120 } else { 121 g_appTid[i] = tids[i]; 122 } 123 } 124} 125 126static void StartCrasherLoopForUnsignedPidAndTid(const CrasherType type) 127{ 128 setuid(BMS_UID); 129 if (type == CRASHER_C) { 130 system("/data/crasher_c thread-Loop &"); 131 } else { 132 system("/data/crasher_cpp thread-Loop &"); 133 } 134 string procCmd = "pgrep 'crasher'"; 135 std::string shellRes = ExecuteCommands(procCmd); 136 if (shellRes.empty()) { 137 exit(1); 138 } 139 g_unsignedLoopSysPid = atoi(shellRes.c_str()); 140 if (g_unsignedLoopSysPid == 0) { 141 exit(0); 142 } 143 144 GetCrasherThreads(g_unsignedLoopSysPid, BMS_UID); 145} 146 147static void LaunchCrasher(const CrasherType type, const int uid) 148{ 149 setuid(uid); 150 if (type == CRASHER_C) { 151 system("/data/crasher_c thread-Loop &"); 152 } else { 153 system("/data/crasher_cpp thread-Loop &"); 154 } 155 156 string procCmd = "pgrep 'crasher'"; 157 std::vector<std::string> ress; 158 ExecuteCommands(procCmd, ress); 159 if (ress.empty()) { 160 exit(0); 161 } 162 163 pid_t curPid = 0; 164 for (size_t i = 0; i < ress.size(); ++i) { 165 pid_t pid = atoi(ress[i].c_str()); 166 if (pid <= 0) { 167 continue; 168 } 169 170 if (uid == ROOT_UID) { 171 if (g_loopSysPid == pid) { 172 continue; 173 } 174 if (type == CRASHER_CPP) { 175 g_loopCppPid = pid; 176 } else { 177 g_loopRootPid = pid; 178 } 179 curPid = g_loopRootPid; 180 GTEST_LOG_(INFO) << "Root ID: " << g_loopRootPid; 181 } else if (uid == BMS_UID) { 182 g_loopSysPid = pid; 183 curPid = g_loopSysPid; 184 GTEST_LOG_(INFO) << "System ID: " << g_loopSysPid; 185 } else { 186 if ((g_loopSysPid == pid) || (g_loopRootPid == pid)) { 187 continue; 188 } else { 189 g_loopAppPid = pid; 190 } 191 curPid = g_loopAppPid; 192 GTEST_LOG_(INFO) << "APP ID: " << g_loopAppPid; 193 } 194 } 195 GetCrasherThreads(curPid, uid); 196} 197 198static void StartCrasherLoop(const CrasherRunType type) 199{ 200 switch (type) { 201 case ROOT: 202 LaunchCrasher(CRASHER_C, ROOT_UID); 203 break; 204 case SYSTEM: 205 LaunchCrasher(CRASHER_C, BMS_UID); 206 break; 207 case APP_CRASHER_C: 208 LaunchCrasher(CRASHER_C, OTHER_UID); 209 break; 210 case APP_CRASHER_CPP: 211 LaunchCrasher(CRASHER_CPP, OTHER_UID); 212 break; 213 default: 214 return; 215 } 216 setuid(OTHER_UID); 217} 218 219static void StopCrasherLoop(const CrasherRunType type) 220{ 221 switch (type) { 222 case ROOT: 223 setuid(ROOT_UID); 224 system(("kill -9 " + to_string(g_loopRootPid)).c_str()); 225 break; 226 case SYSTEM: 227 setuid(BMS_UID); 228 system(("kill -9 " + to_string(g_loopSysPid)).c_str()); 229 break; 230 case APP_CRASHER_C: 231 setuid(ROOT_UID); 232 system(("kill -9 " + to_string(g_loopAppPid)).c_str()); 233 break; 234 case APP_CRASHER_CPP: 235 setuid(BMS_UID); 236 system(("kill -9 " + to_string(g_unsignedLoopSysPid)).c_str()); 237 break; 238 default: 239 break; 240 } 241} 242 243/** 244 * @tc.name: DumpCatcherSystemTest001 245 * @tc.desc: test DumpCatch API: app PID(app), TID(0) 246 * @tc.type: FUNC 247 */ 248HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest001, TestSize.Level2) 249{ 250 GTEST_LOG_(INFO) << "DumpCatcherSystemTest001: start."; 251 StartCrasherLoop(APP_CRASHER_C); 252 DfxDumpCatcher dumplog; 253 string msg = ""; 254 GTEST_LOG_(INFO) << "appPid: " << g_loopAppPid; 255 bool ret = dumplog.DumpCatch(g_loopAppPid, 0, msg); 256 GTEST_LOG_(INFO) << ret; 257 GTEST_LOG_(INFO) << "dump log : \n" << msg; 258 EXPECT_FALSE(ret) << "DumpCatcherSystemTest001 Failed"; 259 StopCrasherLoop(APP_CRASHER_C); 260 GTEST_LOG_(INFO) << "DumpCatcherSystemTest001: end."; 261} 262 263/** 264 * @tc.name: DumpCatcherSystemTest002 265 * @tc.desc: test DumpCatch API: app PID(app), TID(PID) 266 * @tc.type: FUNC 267 */ 268HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest002, TestSize.Level2) 269{ 270 GTEST_LOG_(INFO) << "DumpCatcherSystemTest002: start."; 271 StartCrasherLoop(APP_CRASHER_C); 272 DfxDumpCatcher dumplog; 273 string msg = ""; 274 bool ret = dumplog.DumpCatch(g_loopAppPid, g_loopAppPid, msg); 275 GTEST_LOG_(INFO) << ret; 276 EXPECT_FALSE(ret) << "DumpCatcherSystemTest002 Failed"; 277 StopCrasherLoop(APP_CRASHER_C); 278 GTEST_LOG_(INFO) << "DumpCatcherSystemTest002: end."; 279} 280 281/** 282 * @tc.name: DumpCatcherSystemTest003 283 * @tc.desc: test DumpCatch API: app PID(app), TID(<>PID) 284 * @tc.type: FUNC 285 */ 286HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest003, TestSize.Level2) 287{ 288 GTEST_LOG_(INFO) << "DumpCatcherSystemTest003: start."; 289 StartCrasherLoop(APP_CRASHER_C); 290 DfxDumpCatcher dumplog; 291 string msg = ""; 292 int tid = g_appTid[0]; 293 if (g_loopAppPid == g_appTid[0]) { 294 tid = g_appTid[1]; 295 } 296 bool ret = dumplog.DumpCatch(g_loopAppPid, tid, msg); 297 EXPECT_FALSE(ret) << "DumpCatcherSystemTest003 Failed"; 298 StopCrasherLoop(APP_CRASHER_C); 299 GTEST_LOG_(INFO) << "DumpCatcherSystemTest003: end."; 300} 301 302/** 303 * @tc.name: DumpCatcherSystemTest004 304 * @tc.desc: test DumpCatch API: app PID(system), TID(0) 305 * @tc.type: FUNC 306 */ 307HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest004, TestSize.Level2) 308{ 309 GTEST_LOG_(INFO) << "DumpCatcherSystemTest004: start."; 310 StartCrasherLoop(SYSTEM); 311 StartCrasherLoop(APP_CRASHER_C); 312 DfxDumpCatcher dumplog; 313 string msg = ""; 314 bool ret = dumplog.DumpCatch(g_loopSysPid, 0, msg); 315 GTEST_LOG_(INFO) << ret; 316 GTEST_LOG_(INFO) << "dump log : \n" << msg; 317 EXPECT_FALSE(ret) << "DumpCatcherSystemTest004 Failed"; 318 StopCrasherLoop(SYSTEM); 319 StopCrasherLoop(APP_CRASHER_C); 320 GTEST_LOG_(INFO) << "DumpCatcherSystemTest004: end."; 321} 322 323/** 324 * @tc.name: DumpCatcherSystemTest005 325 * @tc.desc: test DumpCatch API: app PID(root), TID(0) 326 * @tc.type: FUNC 327 */ 328HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest005, TestSize.Level2) 329{ 330 GTEST_LOG_(INFO) << "DumpCatcherSystemTest005: start."; 331 StartCrasherLoop(ROOT); 332 StartCrasherLoop(APP_CRASHER_C); 333 setuid(OTHER_UID); 334 DfxDumpCatcher dumplog; 335 string msg = ""; 336 bool ret = dumplog.DumpCatch(g_loopRootPid, 0, msg); 337 GTEST_LOG_(INFO) << ret; 338 GTEST_LOG_(INFO) << "dump log : \n" << msg; 339 EXPECT_FALSE(ret) << "DumpCatcherSystemTest005 Failed"; 340 StopCrasherLoop(ROOT); 341 StopCrasherLoop(APP_CRASHER_C); 342 GTEST_LOG_(INFO) << "DumpCatcherSystemTest005: end."; 343} 344 345/** 346 * @tc.name: DumpCatcherSystemTest006 347 * @tc.desc: test DumpCatch API: app PID(9999), TID(0) 348 * @tc.type: FUNC 349 */ 350HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest006, TestSize.Level2) 351{ 352 GTEST_LOG_(INFO) << "DumpCatcherSystemTest006: start."; 353 StartCrasherLoop(APP_CRASHER_C); 354 DfxDumpCatcher dumplog; 355 string msg = ""; 356 bool ret = dumplog.DumpCatch(9999, 0, msg); 357 GTEST_LOG_(INFO) << ret; 358 GTEST_LOG_(INFO) << "dump log : \n" << msg; 359 EXPECT_FALSE(ret) << "DumpCatcherSystemTest006 Failed"; 360 StopCrasherLoop(APP_CRASHER_C); 361 GTEST_LOG_(INFO) << "DumpCatcherSystemTest006: end."; 362} 363 364/** 365 * @tc.name: DumpCatcherSystemTest007 366 * @tc.desc: test DumpCatch API: app PID(app), TID(9999) 367 * @tc.type: FUNC 368 */ 369HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest007, TestSize.Level2) 370{ 371 GTEST_LOG_(INFO) << "DumpCatcherSystemTest007: start."; 372 StartCrasherLoop(APP_CRASHER_C); 373 DfxDumpCatcher dumplog; 374 string msg = ""; 375 bool ret = dumplog.DumpCatch(g_loopAppPid, 9999, msg); 376 GTEST_LOG_(INFO) << ret; 377 GTEST_LOG_(INFO) << "dump log : \n" << msg; 378 EXPECT_FALSE(ret) << "DumpCatcherSystemTest007 Failed"; 379 StopCrasherLoop(APP_CRASHER_C); 380 GTEST_LOG_(INFO) << "DumpCatcherSystemTest007: end."; 381} 382 383/** 384 * @tc.name: DumpCatcherSystemTest008 385 * @tc.desc: test DumpCatch API: app PID(app), TID(system) 386 * @tc.type: FUNC 387 */ 388HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest008, TestSize.Level2) 389{ 390 GTEST_LOG_(INFO) << "DumpCatcherSystemTest008 start."; 391 StartCrasherLoop(SYSTEM); 392 StartCrasherLoop(APP_CRASHER_C); 393 DfxDumpCatcher dumplog; 394 string msg = ""; 395 bool ret = dumplog.DumpCatch(g_loopAppPid, g_loopSysPid, msg); 396 GTEST_LOG_(INFO) << ret; 397 GTEST_LOG_(INFO) << "dump log : \n" << msg; 398 EXPECT_FALSE(ret) << "DumpCatcherSystemTest008 Failed"; 399 StopCrasherLoop(SYSTEM); 400 StopCrasherLoop(APP_CRASHER_C); 401 GTEST_LOG_(INFO) << "DumpCatcherSystemTest008: end."; 402} 403 404/** 405 * @tc.name: DumpCatcherSystemTest009 406 * @tc.desc: test DumpCatch API: app PID(0), TID(app) 407 * @tc.type: FUNC 408 */ 409HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest009, TestSize.Level2) 410{ 411 GTEST_LOG_(INFO) << "DumpCatcherSystemTest009 start."; 412 StartCrasherLoop(APP_CRASHER_C); 413 setuid(OTHER_UID); 414 DfxDumpCatcher dumplog; 415 string msg = ""; 416 bool ret = dumplog.DumpCatch(0, g_loopAppPid, msg); 417 GTEST_LOG_(INFO) << ret; 418 GTEST_LOG_(INFO) << "dump log : \n" << msg; 419 EXPECT_FALSE(ret) << "DumpCatcherSystemTest009 Failed"; 420 StopCrasherLoop(APP_CRASHER_C); 421 GTEST_LOG_(INFO) << "DumpCatcherSystemTest009: end."; 422} 423 424/** 425 * @tc.name: DumpCatcherSystemTest010 426 * @tc.desc: test DumpCatch API: PID(-11), TID(0) 427 * @tc.type: FUNC 428 */ 429HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest010, TestSize.Level2) 430{ 431 GTEST_LOG_(INFO) << "DumpCatcherSystemTest010 start."; 432 StartCrasherLoop(APP_CRASHER_C); 433 DfxDumpCatcher dumplog; 434 string msg = ""; 435 bool ret = dumplog.DumpCatch(-11, 0, msg); 436 GTEST_LOG_(INFO) << ret; 437 GTEST_LOG_(INFO) << "dump log : \n" << msg; 438 EXPECT_FALSE(ret) << "DumpCatcherSystemTest010 Failed"; 439 StopCrasherLoop(APP_CRASHER_C); 440 GTEST_LOG_(INFO) << "DumpCatcherSystemTest010: end."; 441} 442 443/** 444 * @tc.name: DumpCatcherSystemTest011 445 * @tc.desc: test DumpCatch API: PID(root), TID(-11) 446 * @tc.type: FUNC 447 */ 448HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest011, TestSize.Level2) 449{ 450 GTEST_LOG_(INFO) << "DumpCatcherSystemTest011 start."; 451 StartCrasherLoop(APP_CRASHER_C); 452 DfxDumpCatcher dumplog; 453 string msg = ""; 454 bool ret = dumplog.DumpCatch(g_loopRootPid, -11, msg); 455 GTEST_LOG_(INFO) << ret; 456 GTEST_LOG_(INFO) << "dump log : \n" << msg; 457 EXPECT_FALSE(ret) << "DumpCatcherSystemTest011 Failed"; 458 StopCrasherLoop(APP_CRASHER_C); 459 GTEST_LOG_(INFO) << "DumpCatcherSystemTest011: end."; 460} 461 462/** 463 * @tc.name: DumpCatcherSystemTest012 464 * @tc.desc: test DumpCatch API: system PID(system), TID(0) 465 * @tc.type: FUNC 466 */ 467HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest012, TestSize.Level2) 468{ 469 GTEST_LOG_(INFO) << "DumpCatcherSystemTest012: start."; 470 StartCrasherLoop(SYSTEM); 471 setuid(BMS_UID); 472 DfxDumpCatcher dumplog; 473 string msg = ""; 474 bool ret = dumplog.DumpCatch(g_loopSysPid, 0, msg); 475 GTEST_LOG_(INFO) << "g_loopSysPid : \n" << g_loopSysPid; 476 string log[] = { "Tid:", "#00", "/data/crasher", "Name:SubTestThread", "usleep"}; 477 log[0] = log[0] + to_string(g_loopSysPid) + ", Name:crasher"; 478 GTEST_LOG_(INFO) << "ret : \n" << ret; 479 GTEST_LOG_(INFO) << "dump log : \n" << msg; 480 int count = GetKeywordsNum(msg, log, sizeof(log) / sizeof(log[0])); 481 setuid(OTHER_UID); 482 EXPECT_EQ(count, 5) << "DumpCatcherSystemTest012 Failed"; 483 StopCrasherLoop(SYSTEM); 484 GTEST_LOG_(INFO) << "DumpCatcherSystemTest012: end."; 485} 486 487/** 488 * @tc.name: DumpCatcherSystemTest013 489 * @tc.desc: test DumpCatch API: root PID(root), TID(0) 490 * @tc.type: FUNC 491 */ 492HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest013, TestSize.Level2) 493{ 494 GTEST_LOG_(INFO) << "DumpCatcherSystemTest013: start."; 495 StartCrasherLoop(ROOT); 496 setuid(ROOT_UID); 497 DfxDumpCatcher dumplog; 498 string msg = ""; 499 bool ret = dumplog.DumpCatch(g_loopRootPid, 0, msg); 500 GTEST_LOG_(INFO) << "g_loopRootPid : \n" << g_loopRootPid; 501 string log[] = { "Tid:", "#00", "/data/crasher", "Name:SubTestThread", "usleep"}; 502 log[0] = log[0] + to_string(g_loopRootPid) + ", Name:crasher"; 503 GTEST_LOG_(INFO) << "ret : \n" << ret; 504 GTEST_LOG_(INFO) << "dump log : \n" << msg; 505 int count = GetKeywordsNum(msg, log, sizeof(log) / sizeof(log[0])); 506 setuid(OTHER_UID); 507 EXPECT_EQ(count, 5) << "DumpCatcherSystemTest013 Failed"; 508 StopCrasherLoop(ROOT); 509 GTEST_LOG_(INFO) << "DumpCatcherSystemTest013: end."; 510} 511 512/** 513 * @tc.name: DumpCatcherSystemTest014 514 * @tc.desc: test DumpCatch API: system PID(app), TID(0) 515 * @tc.type: FUNC 516 */ 517HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest014, TestSize.Level2) 518{ 519 GTEST_LOG_(INFO) << "DumpCatcherSystemTest014: start."; 520 StartCrasherLoop(SYSTEM); 521 StartCrasherLoop(APP_CRASHER_C); 522 setuid(BMS_UID); 523 DfxDumpCatcher dumplog; 524 string msg = ""; 525 bool ret = dumplog.DumpCatch(g_loopAppPid, 0, msg); 526 GTEST_LOG_(INFO) << "ret : \n" << ret; 527 GTEST_LOG_(INFO) << "dump log : \n" << msg; 528 GTEST_LOG_(INFO) << "g_loopAppPid : \n" << g_loopAppPid; 529 string log[] = { "Tid:", "#00", "/data/crasher", "Name:SubTestThread", "usleep"}; 530 log[0] = log[0] + to_string(g_loopAppPid) + ", Name:crasher"; 531 GTEST_LOG_(INFO) << "ret : \n" << ret; 532 GTEST_LOG_(INFO) << "dump log : \n" << msg; 533 int count = GetKeywordsNum(msg, log, sizeof(log) / sizeof(log[0])); 534 setuid(OTHER_UID); 535 EXPECT_EQ(count, 5) << "DumpCatcherSystemTest014 Failed"; 536 StopCrasherLoop(SYSTEM); 537 StopCrasherLoop(APP_CRASHER_C); 538 GTEST_LOG_(INFO) << "DumpCatcherSystemTest014: end."; 539} 540 541/** 542 * @tc.name: DumpCatcherSystemTest015 543 * @tc.desc: test DumpCatch API: system PID(root), TID(0) 544 * @tc.type: FUNC 545 */ 546HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest015, TestSize.Level2) 547{ 548 GTEST_LOG_(INFO) << "DumpCatcherSystemTest015: start."; 549 StartCrasherLoop(SYSTEM); 550 StartCrasherLoop(ROOT); 551 setuid(BMS_UID); 552 DfxDumpCatcher dumplog; 553 string msg = ""; 554 bool ret = dumplog.DumpCatch(g_loopRootPid, 0, msg); 555 GTEST_LOG_(INFO) << "ret : \n" << ret; 556 GTEST_LOG_(INFO) << "dump log : \n" << msg; 557 GTEST_LOG_(INFO) << "g_loopRootPid : \n" << g_loopRootPid; 558 string log[] = { "Tid:", "#00", "/data/crasher", "Name:SubTestThread", "usleep"}; 559 log[0] = log[0] + to_string(g_loopRootPid) + ", Name:crasher"; 560 GTEST_LOG_(INFO) << "ret : \n" << ret; 561 GTEST_LOG_(INFO) << "dump log : \n" << msg; 562 int count = GetKeywordsNum(msg, log, sizeof(log) / sizeof(log[0])); 563 setuid(OTHER_UID); 564 EXPECT_EQ(count, 5) << "DumpCatcherSystemTest015 Failed"; 565 StopCrasherLoop(SYSTEM); 566 StopCrasherLoop(ROOT); 567 GTEST_LOG_(INFO) << "DumpCatcherSystemTest015: end."; 568} 569 570/** 571 * @tc.name: DumpCatcherSystemTest016 572 * @tc.desc: test DumpCatch API: root PID(system), TID(0) 573 * @tc.type: FUNC 574 */ 575HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest016, TestSize.Level2) 576{ 577 GTEST_LOG_(INFO) << "DumpCatcherSystemTest016: start."; 578 StartCrasherLoop(SYSTEM); 579 StartCrasherLoop(ROOT); 580 setuid(ROOT_UID); 581 DfxDumpCatcher dumplog; 582 string msg = ""; 583 bool ret = dumplog.DumpCatch(g_loopSysPid, 0, msg); 584 GTEST_LOG_(INFO) << "ret : \n" << ret; 585 GTEST_LOG_(INFO) << "dump log : \n" << msg; 586 GTEST_LOG_(INFO) << "g_loopSysPid : \n" << g_loopSysPid; 587 string log[] = { "Tid:", "#00", "/data/crasher", "Name:SubTestThread", "usleep"}; 588 log[0] = log[0] + to_string(g_loopSysPid) + ", Name:crasher"; 589 GTEST_LOG_(INFO) << "ret : \n" << ret; 590 GTEST_LOG_(INFO) << "dump log : \n" << msg; 591 int count = GetKeywordsNum(msg, log, sizeof(log) / sizeof(log[0])); 592 setuid(OTHER_UID); 593 EXPECT_EQ(count, 5) << "DumpCatcherSystemTest016 Failed"; 594 StopCrasherLoop(SYSTEM); 595 StopCrasherLoop(ROOT); 596 GTEST_LOG_(INFO) << "DumpCatcherSystemTest016: end."; 597} 598 599/** 600 * @tc.name: DumpCatcherSystemTest017 601 * @tc.desc: test DumpCatch API: root PID(app), TID(0) 602 * @tc.type: FUNC 603 */ 604HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest017, TestSize.Level2) 605{ 606 GTEST_LOG_(INFO) << "DumpCatcherSystemTest017: start."; 607 StartCrasherLoop(APP_CRASHER_C); 608 StartCrasherLoop(ROOT); 609 setuid(ROOT_UID); 610 DfxDumpCatcher dumplog; 611 string msg = ""; 612 bool ret = dumplog.DumpCatch(g_loopAppPid, 0, msg); 613 GTEST_LOG_(INFO) << "ret : \n" << ret; 614 GTEST_LOG_(INFO) << "dump log : \n" << msg; 615 GTEST_LOG_(INFO) << "g_loopAppPid : \n" << g_loopAppPid; 616 string log[] = { "Tid:", "#00", "/data/crasher", "Name:SubTestThread", "usleep"}; 617 log[0] = log[0] + to_string(g_loopAppPid) + ", Name:crasher"; 618 GTEST_LOG_(INFO) << "ret : \n" << ret; 619 GTEST_LOG_(INFO) << "dump log : \n" << msg; 620 int count = GetKeywordsNum(msg, log, sizeof(log) / sizeof(log[0])); 621 setuid(OTHER_UID); 622 EXPECT_EQ(count, 5) << "DumpCatcherSystemTest017 Failed"; 623 StopCrasherLoop(APP_CRASHER_C); 624 StopCrasherLoop(ROOT); 625 GTEST_LOG_(INFO) << "DumpCatcherSystemTest017: end."; 626} 627 628/** 629 * @tc.name: DumpCatcherSystemTest018 630 * @tc.desc: test DumpCatch API: app PID(app), TID(root) 631 * @tc.type: FUNC 632 */ 633HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest018, TestSize.Level2) 634{ 635 GTEST_LOG_(INFO) << "DumpCatcherSystemTest018 start."; 636 StartCrasherLoop(APP_CRASHER_C); 637 DfxDumpCatcher dumplog; 638 string msg = ""; 639 bool ret = dumplog.DumpCatch(g_loopAppPid, g_loopRootPid, msg); 640 GTEST_LOG_(INFO) << ret; 641 GTEST_LOG_(INFO) << "dump log : \n" << msg; 642 EXPECT_FALSE(ret) << "DumpCatcherSystemTest018 Failed"; 643 StopCrasherLoop(APP_CRASHER_C); 644 GTEST_LOG_(INFO) << "DumpCatcherSystemTest018: end."; 645} 646 647/** 648 * @tc.name: DumpCatcherSystemTest019 649 * @tc.desc: test DumpCatch API: PID(root), TID(app) 650 * @tc.type: FUNC 651 */ 652HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest019, TestSize.Level2) 653{ 654 GTEST_LOG_(INFO) << "DumpCatcherSystemTest019 start."; 655 StartCrasherLoop(APP_CRASHER_C); 656 DfxDumpCatcher dumplog; 657 string msg = ""; 658 bool ret = dumplog.DumpCatch(g_loopRootPid, g_loopAppPid, msg); 659 GTEST_LOG_(INFO) << ret; 660 GTEST_LOG_(INFO) << "dump log : \n" << msg; 661 EXPECT_FALSE(ret) << "DumpCatcherSystemTest019 Failed"; 662 StopCrasherLoop(APP_CRASHER_C); 663 GTEST_LOG_(INFO) << "DumpCatcherSystemTest019: end."; 664} 665 666/** 667 * @tc.name: DumpCatcherSystemTest020 668 * @tc.desc: test dumpcatcher command: dumpcatcher -p apppid 669 * @tc.type: FUNC 670 */ 671HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest020, TestSize.Level2) 672{ 673 GTEST_LOG_(INFO) << "DumpCatcherSystemTest020: start uid:" << getuid(); 674 StartCrasherLoop(APP_CRASHER_C); 675 string procCMD = "dumpcatcher -p " + to_string(g_loopAppPid); 676 string procDumpLog = ExecuteCommands(procCMD); 677 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 678 string log[] = {"Failed"}; 679 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 680 GTEST_LOG_(INFO) << count; 681 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest020 Failed"; 682 StopCrasherLoop(APP_CRASHER_C); 683 GTEST_LOG_(INFO) << "DumpCatcherSystemTest020: end."; 684} 685 686/** 687 * @tc.name: DumpCatcherSystemTest021 688 * @tc.desc: test dumpcatcher command: dumpcatcher -p apppid -t apppid 689 * @tc.type: FUNC 690 */ 691HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest021, TestSize.Level2) 692{ 693 GTEST_LOG_(INFO) << "DumpCatcherSystemTest021: start uid:" << getuid(); 694 StartCrasherLoop(APP_CRASHER_C); 695 string procCMD = "dumpcatcher -p " + to_string(g_loopAppPid) + " -t " + to_string(g_loopAppPid); 696 string procDumpLog = ExecuteCommands(procCMD); 697 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 698 string log[] = {"Failed"}; 699 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 700 GTEST_LOG_(INFO) << count; 701 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest021 Failed"; 702 StopCrasherLoop(APP_CRASHER_C); 703 GTEST_LOG_(INFO) << "DumpCatcherSystemTest021: end."; 704} 705 706/** 707 * @tc.name: DumpCatcherSystemTest022 708 * @tc.desc: test dumpcatcher command: dumpcatcher -p apppid -t apptid 709 * @tc.type: FUNC 710 */ 711HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest022, TestSize.Level2) 712{ 713 GTEST_LOG_(INFO) << "DumpCatcherSystemTest022: start uid:" << getuid(); 714 StartCrasherLoop(APP_CRASHER_C); 715 int tid = g_appTid[0]; 716 if (g_loopAppPid == g_appTid[0]) { 717 tid = g_appTid[1]; 718 } 719 string procCMD = "dumpcatcher -p " + to_string(g_loopAppPid) + " -t " + to_string(tid); 720 string procDumpLog = ExecuteCommands(procCMD); 721 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 722 string log[] = {"Failed"}; 723 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 724 GTEST_LOG_(INFO) << count; 725 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest022 Failed"; 726 StopCrasherLoop(APP_CRASHER_C); 727 GTEST_LOG_(INFO) << "DumpCatcherSystemTest022: end."; 728} 729 730/** 731 * @tc.name: DumpCatcherSystemTest023 732 * @tc.desc: test dumpcatcher command: -p systempid 733 * @tc.type: FUNC 734 */ 735HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest023, TestSize.Level2) 736{ 737 GTEST_LOG_(INFO) << "DumpCatcherSystemTest023: start."; 738 StartCrasherLoop(SYSTEM); 739 StartCrasherLoop(APP_CRASHER_C); 740 string procCMD = "dumpcatcher -p " + to_string(g_loopSysPid) + " -t " + to_string(g_loopSysPid); 741 string procDumpLog = ExecuteCommands(procCMD); 742 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 743 string log[] = {"Failed"}; 744 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 745 GTEST_LOG_(INFO) << count; 746 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest023 Failed"; 747 StopCrasherLoop(SYSTEM); 748 StopCrasherLoop(APP_CRASHER_C); 749 GTEST_LOG_(INFO) << "DumpCatcherSystemTest023: end."; 750} 751 752/** 753 * @tc.name: DumpCatcherSystemTest024 754 * @tc.desc: test dumpcatcher command: -p rootpid 755 * @tc.type: FUNC 756 */ 757HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest024, TestSize.Level2) 758{ 759 GTEST_LOG_(INFO) << "DumpCatcherSystemTest024: start."; 760 StartCrasherLoop(ROOT); 761 StartCrasherLoop(APP_CRASHER_C); 762 string procCMD = "dumpcatcher -p " + to_string(g_loopRootPid) + " -t " + to_string(g_loopRootPid); 763 string procDumpLog = ExecuteCommands(procCMD); 764 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 765 string log[] = {"Failed"}; 766 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 767 GTEST_LOG_(INFO) << count; 768 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest024 Failed"; 769 StopCrasherLoop(ROOT); 770 StopCrasherLoop(APP_CRASHER_C); 771 GTEST_LOG_(INFO) << "DumpCatcherSystemTest024: end."; 772} 773 774/** 775 * @tc.name: DumpCatcherSystemTest025 776 * @tc.desc: test dumpcatcher command: -p 9999 -t apppid 777 * @tc.type: FUNC 778 */ 779HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest025, TestSize.Level2) 780{ 781 GTEST_LOG_(INFO) << "DumpCatcherSystemTest025: start."; 782 StartCrasherLoop(APP_CRASHER_C); 783 string procCMD = "dumpcatcher -p 9999 -t "+ to_string(g_loopAppPid); 784 string procDumpLog = ExecuteCommands(procCMD); 785 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 786 string log[] = {"Failed"}; 787 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 788 GTEST_LOG_(INFO) << count; 789 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest025 Failed"; 790 StopCrasherLoop(APP_CRASHER_C); 791 GTEST_LOG_(INFO) << "DumpCatcherSystemTest025: end."; 792} 793 794/** 795 * @tc.name: DumpCatcherSystemTest026 796 * @tc.desc: test dumpcatcher command: -p apppid -t 9999 797 * @tc.type: FUNC 798 */ 799HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest026, TestSize.Level2) 800{ 801 GTEST_LOG_(INFO) << "DumpCatcherSystemTest026: start."; 802 StartCrasherLoop(APP_CRASHER_C); 803 string procCMD = "dumpcatcher -p " + to_string(g_loopAppPid) + " -t 9999"; 804 string procDumpLog = ExecuteCommands(procCMD); 805 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 806 string log[] = {"Failed"}; 807 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 808 GTEST_LOG_(INFO) << count; 809 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest026 Failed"; 810 StopCrasherLoop(APP_CRASHER_C); 811 GTEST_LOG_(INFO) << "DumpCatcherSystemTest026: end."; 812} 813 814/** 815 * @tc.name: DumpCatcherSystemTest027 816 * @tc.desc: test dumpcatcher command: -p apppid -t systempid 817 * @tc.type: FUNC 818 */ 819HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest027, TestSize.Level2) 820{ 821 GTEST_LOG_(INFO) << "DumpCatcherSystemTest027: start."; 822 StartCrasherLoop(SYSTEM); 823 StartCrasherLoop(APP_CRASHER_C); 824 string procCMD = "dumpcatcher -p " + to_string(g_loopAppPid) + " -t " + to_string(g_loopSysPid); 825 string procDumpLog = ExecuteCommands(procCMD); 826 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 827 string log[] = {"Failed"}; 828 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 829 GTEST_LOG_(INFO) << count; 830 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest027 Failed"; 831 StopCrasherLoop(SYSTEM); 832 StopCrasherLoop(APP_CRASHER_C); 833 GTEST_LOG_(INFO) << "DumpCatcherSystemTest027: end."; 834} 835 836/** 837 * @tc.name: DumpCatcherSystemTest028 838 * @tc.desc: test dumpcatcher command: -p systempid -t apppid 839 * @tc.type: FUNC 840 */ 841HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest028, TestSize.Level2) 842{ 843 GTEST_LOG_(INFO) << "DumpCatcherSystemTest028: start."; 844 StartCrasherLoop(SYSTEM); 845 StartCrasherLoop(APP_CRASHER_C); 846 string procCMD = "dumpcatcher -p " + to_string(g_loopSysPid) + " -t " + to_string(g_loopAppPid); 847 string procDumpLog = ExecuteCommands(procCMD); 848 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 849 string log[] = {"Failed"}; 850 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 851 GTEST_LOG_(INFO) << count; 852 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest028 Failed"; 853 StopCrasherLoop(SYSTEM); 854 StopCrasherLoop(APP_CRASHER_C); 855 GTEST_LOG_(INFO) << "DumpCatcherSystemTest028: end."; 856} 857 858/** 859 * @tc.name: DumpCatcherSystemTest029 860 * @tc.desc: test dumpcatcher command: -p -t apppid 861 * @tc.type: FUNC 862 */ 863HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest029, TestSize.Level2) 864{ 865 GTEST_LOG_(INFO) << "DumpCatcherSystemTest029: start."; 866 StartCrasherLoop(APP_CRASHER_C); 867 string procCMD = "dumpcatcher -p -t " + to_string(g_loopAppPid); 868 string procDumpLog = ExecuteCommands(procCMD); 869 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 870 string log[] = {"Failed"}; 871 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 872 GTEST_LOG_(INFO) << count; 873 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest029 Failed"; 874 StopCrasherLoop(APP_CRASHER_C); 875 GTEST_LOG_(INFO) << "DumpCatcherSystemTest029: end."; 876} 877 878/** 879 * @tc.name: DumpCatcherSystemTest030 880 * @tc.desc: test dumpcatcher command: -p apppid -t 881 * @tc.type: FUNC 882 */ 883HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest030, TestSize.Level2) 884{ 885 GTEST_LOG_(INFO) << "DumpCatcherSystemTest030: start."; 886 StartCrasherLoop(APP_CRASHER_C); 887 string procCMD = "dumpcatcher -p " + to_string(g_loopAppPid) + " -t "; 888 string procDumpLog = ExecuteCommands(procCMD); 889 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 890 string log[] = {"Usage:", "dump the stacktrace"}; 891 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 892 GTEST_LOG_(INFO) << count; 893 EXPECT_EQ(count, 2) << "DumpCatcherSystemTest030 Failed"; 894 StopCrasherLoop(APP_CRASHER_C); 895 GTEST_LOG_(INFO) << "DumpCatcherSystemTest030: end."; 896} 897 898/** 899 * @tc.name: DumpCatcherSystemTest031 900 * @tc.desc: test dumpcatcher command: -p -11 -t apppid 901 * @tc.type: FUNC 902 */ 903HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest031, TestSize.Level2) 904{ 905 GTEST_LOG_(INFO) << "DumpCatcherSystemTest031: start."; 906 StartCrasherLoop(APP_CRASHER_C); 907 string procCMD = "dumpcatcher -p -11 -t " + to_string(g_loopAppPid); 908 string procDumpLog = ExecuteCommands(procCMD); 909 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 910 string log[] = {"Failed"}; 911 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 912 GTEST_LOG_(INFO) << count; 913 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest031 Failed"; 914 StopCrasherLoop(APP_CRASHER_C); 915 GTEST_LOG_(INFO) << "DumpCatcherSystemTest031: end."; 916} 917 918/** 919 * @tc.name: DumpCatcherSystemTest032 920 * @tc.desc: test dumpcatcher command: -p apppid -t -11 921 * @tc.type: FUNC 922 */ 923HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest032, TestSize.Level2) 924{ 925 GTEST_LOG_(INFO) << "DumpCatcherSystemTest032: start."; 926 StartCrasherLoop(APP_CRASHER_C); 927 string procCMD = "dumpcatcher -p " + to_string(g_loopAppPid) + " -t -11"; 928 string procDumpLog = ExecuteCommands(procCMD); 929 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 930 string log[] = {"Failed"}; 931 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 932 GTEST_LOG_(INFO) << count; 933 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest032 Failed"; 934 StopCrasherLoop(APP_CRASHER_C); 935 GTEST_LOG_(INFO) << "DumpCatcherSystemTest032: end."; 936} 937 938/** 939 * @tc.name: DumpCatcherSystemTest033 940 * @tc.desc: test dumpcatcher command: -p systempid 941 * @tc.type: FUNC 942 */ 943HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest033, TestSize.Level2) 944{ 945 GTEST_LOG_(INFO) << "DumpCatcherSystemTest033: start."; 946 StartCrasherLoop(SYSTEM); 947 setuid(BMS_UID); 948 string procCMD = "dumpcatcher -p " + to_string(g_loopSysPid); 949 string procDumpLog = ExecuteCommands(procCMD); 950 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 951 string log[] = {"", "Name:crasher", "Name:SubTestThread", "#00", "/data/crasher"}; 952 log[0] = log[0] + to_string(g_loopSysPid); 953 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 954 GTEST_LOG_(INFO) << count; 955 setuid(OTHER_UID); 956 EXPECT_EQ(count, 5) << "DumpCatcherSystemTest033 Failed"; 957 StopCrasherLoop(SYSTEM); 958 GTEST_LOG_(INFO) << "DumpCatcherSystemTest033: end."; 959} 960 961/** 962 * @tc.name: DumpCatcherSystemTest034 963 * @tc.desc: test dumpcatcher command: -p rootpid 964 * @tc.type: FUNC 965 */ 966HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest034, TestSize.Level2) 967{ 968 GTEST_LOG_(INFO) << "DumpCatcherSystemTest034: start."; 969 StartCrasherLoop(ROOT); 970 setuid(ROOT_UID); 971 string procCMD = "dumpcatcher -p " + to_string(g_loopRootPid); 972 string procDumpLog = ExecuteCommands(procCMD); 973 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 974 string log[] = {"", "Name:crasher", "Name:SubTestThread", "#00", "/data/crasher"}; 975 log[0] = log[0] + to_string(g_loopRootPid); 976 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 977 GTEST_LOG_(INFO) << count; 978 setuid(OTHER_UID); 979 EXPECT_EQ(count, 5) << "DumpCatcherSystemTest034 Failed"; 980 StopCrasherLoop(ROOT); 981 GTEST_LOG_(INFO) << "DumpCatcherSystemTest034: end."; 982} 983 984/** 985 * @tc.name: DumpCatcherSystemTest035 986 * @tc.desc: test dumpcatcher command: -p apppid 987 * @tc.type: FUNC 988 */ 989HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest035, TestSize.Level2) 990{ 991 GTEST_LOG_(INFO) << "DumpCatcherSystemTest035: start."; 992 StartCrasherLoop(APP_CRASHER_C); 993 StartCrasherLoop(SYSTEM); 994 setuid(BMS_UID); 995 string procCMD = "dumpcatcher -p " + to_string(g_loopAppPid); 996 string procDumpLog = ExecuteCommands(procCMD); 997 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 998 string log[] = {"", "Name:crasher", "Name:SubTestThread", "#00", "/data/crasher"}; 999 log[0] = log[0] + to_string(g_loopAppPid); 1000 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 1001 GTEST_LOG_(INFO) << count; 1002 setuid(OTHER_UID); 1003 EXPECT_EQ(count, 5) << "DumpCatcherSystemTest035 Failed"; 1004 StopCrasherLoop(APP_CRASHER_C); 1005 StopCrasherLoop(SYSTEM); 1006 GTEST_LOG_(INFO) << "DumpCatcherSystemTest035: end."; 1007} 1008 1009/** 1010 * @tc.name: DumpCatcherSystemTest036 1011 * @tc.desc: test dumpcatcher command: -p apppid 1012 * @tc.type: FUNC 1013 */ 1014HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest036, TestSize.Level2) 1015{ 1016 GTEST_LOG_(INFO) << "DumpCatcherSystemTest036: start."; 1017 StartCrasherLoop(ROOT); 1018 StartCrasherLoop(SYSTEM); 1019 setuid(BMS_UID); 1020 string procCMD = "dumpcatcher -p " + to_string(g_loopRootPid); 1021 string procDumpLog = ExecuteCommands(procCMD); 1022 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 1023 string log[] = {"", "Name:crasher", "Name:SubTestThread", "#00", "/data/crasher"}; 1024 log[0] = log[0] + to_string(g_loopRootPid); 1025 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 1026 GTEST_LOG_(INFO) << count; 1027 setuid(OTHER_UID); 1028 EXPECT_EQ(count, 5) << "DumpCatcherSystemTest036 Failed"; 1029 StopCrasherLoop(ROOT); 1030 StopCrasherLoop(SYSTEM); 1031 GTEST_LOG_(INFO) << "DumpCatcherSystemTest036: end."; 1032} 1033 1034/** 1035 * @tc.name: DumpCatcherSystemTest037 1036 * @tc.desc: test dumpcatcher command: -p apppid 1037 * @tc.type: FUNC 1038 */ 1039HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest037, TestSize.Level2) 1040{ 1041 GTEST_LOG_(INFO) << "DumpCatcherSystemTest037: start."; 1042 StartCrasherLoop(APP_CRASHER_C); 1043 StartCrasherLoop(ROOT); 1044 setuid(ROOT_UID); 1045 string procCMD = "dumpcatcher -p " + to_string(g_loopAppPid); 1046 string procDumpLog = ExecuteCommands(procCMD); 1047 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 1048 string log[] = {"", "Name:crasher", "Name:SubTestThread", "#00", "/data/crasher", ""}; 1049 log[0] = log[0] + to_string(g_appTid[0]); 1050 log[5] = log[5] + to_string(g_appTid[1]); 1051 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 1052 GTEST_LOG_(INFO) << count; 1053 setuid(OTHER_UID); 1054 EXPECT_EQ(count, 6) << "DumpCatcherSystemTest037 Failed"; 1055 StopCrasherLoop(APP_CRASHER_C); 1056 StopCrasherLoop(ROOT); 1057 GTEST_LOG_(INFO) << "DumpCatcherSystemTest037: end."; 1058} 1059 1060/** 1061 * @tc.name: DumpCatcherSystemTest038 1062 * @tc.desc: test dumpcatcher command: -p sytempid 1063 * @tc.type: FUNC 1064 */ 1065HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest038, TestSize.Level2) 1066{ 1067 GTEST_LOG_(INFO) << "DumpCatcherSystemTest038: start."; 1068 StartCrasherLoop(SYSTEM); 1069 StartCrasherLoop(ROOT); 1070 setuid(ROOT_UID); 1071 string procCMD = "dumpcatcher -p " + to_string(g_loopSysPid); 1072 string procDumpLog = ExecuteCommands(procCMD); 1073 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 1074 string log[] = {"", "Name:crasher", "Name:SubTestThread", "#00", "/data/crasher", ""}; 1075 log[0] = log[0] + to_string(g_sysTid[0]); 1076 log[5] = log[5] + to_string(g_sysTid[1]); 1077 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 1078 GTEST_LOG_(INFO) << count; 1079 setuid(OTHER_UID); 1080 EXPECT_EQ(count, 6) << "DumpCatcherSystemTest038 Failed"; 1081 StopCrasherLoop(SYSTEM); 1082 StopCrasherLoop(ROOT); 1083 GTEST_LOG_(INFO) << "DumpCatcherSystemTest038: end."; 1084} 1085 1086/** 1087 * @tc.name: DumpCatcherSystemTest039 1088 * @tc.desc: test dumpcatcher command: -p apppid -t rootpid 1089 * @tc.type: FUNC 1090 */ 1091HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest039, TestSize.Level2) 1092{ 1093 GTEST_LOG_(INFO) << "DumpCatcherSystemTest039: start."; 1094 StartCrasherLoop(ROOT); 1095 StartCrasherLoop(APP_CRASHER_C); 1096 string procCMD = "dumpcatcher -p " + to_string(g_loopAppPid) + " -t " + to_string(g_loopRootPid); 1097 string procDumpLog = ExecuteCommands(procCMD); 1098 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 1099 string log[] = {"Failed"}; 1100 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 1101 GTEST_LOG_(INFO) << count; 1102 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest039 Failed"; 1103 StopCrasherLoop(ROOT); 1104 StopCrasherLoop(APP_CRASHER_C); 1105 GTEST_LOG_(INFO) << "DumpCatcherSystemTest039: end."; 1106} 1107 1108/** 1109 * @tc.name: DumpCatcherSystemTest040 1110 * @tc.desc: test dumpcatcher command: -p rootpid, -t apppid 1111 * @tc.type: FUNC 1112 */ 1113HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest040, TestSize.Level2) 1114{ 1115 GTEST_LOG_(INFO) << "DumpCatcherSystemTest040: start."; 1116 StartCrasherLoop(ROOT); 1117 StartCrasherLoop(APP_CRASHER_C); 1118 string procCMD = "dumpcatcher -p " + to_string(g_loopRootPid) + " -t " + to_string(g_loopAppPid); 1119 string procDumpLog = ExecuteCommands(procCMD); 1120 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 1121 string log[] = {"Failed"}; 1122 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 1123 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest040 Failed"; 1124 StopCrasherLoop(ROOT); 1125 StopCrasherLoop(APP_CRASHER_C); 1126 GTEST_LOG_(INFO) << "DumpCatcherSystemTest040: end."; 1127} 1128 1129/** 1130 * @tc.name: DumpCatcherSystemTest041 1131 * @tc.desc: test dumpcatcher command: -p pid-max, -t threads_max 1132 * @tc.type: FUNC 1133 */ 1134HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest041, TestSize.Level2) 1135{ 1136 GTEST_LOG_(INFO) << "DumpCatcherSystemTest041: start."; 1137 StartCrasherLoop(APP_CRASHER_C); 1138 string procCMD = "dumpcatcher -p " + GetPidMax() + " -t " + GetTidMax(); 1139 string procDumpLog = ExecuteCommands(procCMD); 1140 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 1141 string log[] = {"Failed"}; 1142 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 1143 GTEST_LOG_(INFO) << count; 1144 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest041 Failed"; 1145 StopCrasherLoop(APP_CRASHER_C); 1146 GTEST_LOG_(INFO) << "DumpCatcherSystemTest041: end."; 1147} 1148 1149/** 1150 * @tc.name: DumpCatcherSystemTest042 1151 * @tc.desc: test dumpcatcher command: -p 65535, -t 65535 1152 * @tc.type: FUNC 1153 */ 1154HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest042, TestSize.Level2) 1155{ 1156 GTEST_LOG_(INFO) << "DumpCatcherSystemTest042: start."; 1157 StartCrasherLoop(APP_CRASHER_C); 1158 string procCMD = "dumpcatcher -p 65535 -t 65535"; 1159 string procDumpLog = ExecuteCommands(procCMD); 1160 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 1161 string log[] = {"Failed"}; 1162 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 1163 GTEST_LOG_(INFO) << count; 1164 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest042 Failed"; 1165 StopCrasherLoop(APP_CRASHER_C); 1166 GTEST_LOG_(INFO) << "DumpCatcherSystemTest042: end."; 1167} 1168 1169/** 1170 * @tc.name: DumpCatcherSystemTest043 1171 * @tc.desc: test dumpcatcher command: -p 65536, -t 65536 1172 * @tc.type: FUNC 1173 */ 1174HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest043, TestSize.Level2) 1175{ 1176 GTEST_LOG_(INFO) << "DumpCatcherSystemTest043: start."; 1177 StartCrasherLoop(APP_CRASHER_C); 1178 string procCMD = "dumpcatcher -p 65536 -t 65536"; 1179 string procDumpLog = ExecuteCommands(procCMD); 1180 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 1181 string log[] = {"Failed"}; 1182 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 1183 GTEST_LOG_(INFO) << count; 1184 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest043 Failed"; 1185 StopCrasherLoop(APP_CRASHER_C); 1186 GTEST_LOG_(INFO) << "DumpCatcherSystemTest043: end."; 1187} 1188 1189/** 1190 * @tc.name: DumpCatcherSystemTest044 1191 * @tc.desc: test dumpcatcher command: -p 65534, -t 65534 1192 * @tc.type: FUNC 1193 */ 1194HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest044, TestSize.Level2) 1195{ 1196 GTEST_LOG_(INFO) << "DumpCatcherSystemTest117: start."; 1197 StartCrasherLoop(APP_CRASHER_C); 1198 string procCMD = "dumpcatcher -p 65534 -t 65534"; 1199 string procDumpLog = ExecuteCommands(procCMD); 1200 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 1201 string log[] = {"Failed"}; 1202 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 1203 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest044 Failed"; 1204 StopCrasherLoop(APP_CRASHER_C); 1205 GTEST_LOG_(INFO) << "DumpCatcherSystemTest044: end."; 1206} 1207 1208/** 1209 * @tc.name: DumpCatcherSystemTest045 1210 * @tc.desc: test CPP DumpCatch API: PID(apppid), TID(0) 1211 * @tc.type: FUNC 1212 */ 1213HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest045, TestSize.Level2) 1214{ 1215 GTEST_LOG_(INFO) << "DumpCatcherSystemTest045: start uid:" << getuid(); 1216 StartCrasherLoop(APP_CRASHER_CPP); 1217 DfxDumpCatcher dumplog; 1218 string msg = ""; 1219 bool ret = dumplog.DumpCatch(g_loopAppPid, 0, msg); 1220 GTEST_LOG_(INFO) << ret; 1221 GTEST_LOG_(INFO) << "dump log : \n" << msg; 1222 EXPECT_FALSE(ret) << "DumpCatcherSystemTest045 Failed"; 1223 StopCrasherLoop(APP_CRASHER_C); 1224 GTEST_LOG_(INFO) << "DumpCatcherSystemTest045: end."; 1225} 1226 1227/** 1228 * @tc.name: DumpCatcherSystemTest046 1229 * @tc.desc: test dumpcatcher command: -p rootpid 1230 * @tc.type: FUNC 1231 */ 1232HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest046, TestSize.Level2) 1233{ 1234 GTEST_LOG_(INFO) << "DumpCatcherSystemTest046: start uid:" << getuid(); 1235 StartCrasherLoop(APP_CRASHER_CPP); 1236 string procCMD = "dumpcatcher -p " + to_string(g_loopAppPid); 1237 string procDumpLog = ExecuteCommands(procCMD); 1238 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 1239 string log[] = {"Failed"}; 1240 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 1241 EXPECT_EQ(count, 1) << "DumpCatcherSystemTest046 Failed"; 1242 StopCrasherLoop(APP_CRASHER_C); 1243 GTEST_LOG_(INFO) << "DumpCatcherSystemTest046: end."; 1244} 1245 1246/** 1247 * @tc.name: DumpCatcherSystemTest047 1248 * @tc.desc: test DumpCatch API: app unsigned PID(systempid), unsigned TID(systempid) 1249 * @tc.type: FUNC 1250 */ 1251HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest047, TestSize.Level2) 1252{ 1253 GTEST_LOG_(INFO) << "DumpCatcherSystemTest047: start."; 1254 StartCrasherLoopForUnsignedPidAndTid(CRASHER_C); 1255 DfxDumpCatcher dumplog; 1256 string msg = ""; 1257 bool ret = dumplog.DumpCatch(g_unsignedLoopSysPid, g_unsignedLoopSysPid, msg); 1258 GTEST_LOG_(INFO) << ret; 1259 GTEST_LOG_(INFO) << msg; 1260 string log[] = {"Tid:", "Name:crasher", "#00", "/data/crasher"}; 1261 log[0] = log[0] + to_string(g_unsignedLoopSysPid); 1262 int count = GetKeywordsNum(msg, log, sizeof(log) / sizeof(log[0])); 1263 GTEST_LOG_(INFO) << count; 1264 EXPECT_EQ(count, 4) << "DumpCatcherSystemTest047 Failed"; 1265 StopCrasherLoop(APP_CRASHER_CPP); 1266 GTEST_LOG_(INFO) << "DumpCatcherSystemTest047: end."; 1267} 1268 1269/** 1270 * @tc.name: DumpCatcherSystemTest048 1271 * @tc.desc: test DumpCatch API: app unsigned PID(systempid), unsigned TID(systempid) 1272 * @tc.type: FUNC 1273 */ 1274HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest048, TestSize.Level2) 1275{ 1276 GTEST_LOG_(INFO) << "DumpCatcherSystemTest048: start."; 1277 StartCrasherLoopForUnsignedPidAndTid(CRASHER_CPP); 1278 DfxDumpCatcher dumplog; 1279 string msg = ""; 1280 bool ret = dumplog.DumpCatch(g_unsignedLoopSysPid, g_unsignedLoopSysPid, msg); 1281 GTEST_LOG_(INFO) << ret; 1282 GTEST_LOG_(INFO) << msg; 1283 string log[] = {"Tid:", "Name:crasher", "#00", "/data/crasher"}; 1284 log[0] = log[0] + to_string(g_unsignedLoopSysPid); 1285 int count = GetKeywordsNum(msg, log, sizeof(log) / sizeof(log[0])); 1286 GTEST_LOG_(INFO) << count; 1287 EXPECT_EQ(count, 4) << "DumpCatcherSystemTest048 Failed"; 1288 StopCrasherLoop(APP_CRASHER_CPP); 1289 GTEST_LOG_(INFO) << "DumpCatcherSystemTest048: end."; 1290} 1291 1292NOINLINE int TestFunc6(std::atomic_int* tid, std::atomic_bool* done) 1293{ 1294 tid->store(gettid()); 1295 while (!done->load()) { 1296 usleep(100); // 100 : pause for 100 microseconds to avoid excessive CPU resource consumption in the loop. 1297 } 1298 return 1; 1299} 1300 1301NOINLINE int TestFunc5(std::atomic_int* tid, std::atomic_bool* done) 1302{ 1303 int val = TestFunc6(tid, done); 1304 return val * val + 1; 1305} 1306 1307NOINLINE int TestFunc4(std::atomic_int* tid, std::atomic_bool* done) 1308{ 1309 int val = TestFunc5(tid, done); 1310 return val * val + 1; 1311} 1312 1313NOINLINE int TestFunc3(std::atomic_int* tid, std::atomic_bool* done) 1314{ 1315 int val = TestFunc4(tid, done); 1316 return val * val + 1; 1317} 1318 1319NOINLINE int TestFunc2(std::atomic_int* tid, std::atomic_bool* done) 1320{ 1321 int val = TestFunc3(tid, done); 1322 return val * val + 1; 1323} 1324 1325NOINLINE int TestFunc1(std::atomic_int* tid, std::atomic_bool* done) 1326{ 1327 int val = TestFunc2(tid, done); 1328 return val * val + 1; 1329} 1330 1331/** 1332 * @tc.name: DumpCatcherSystemTest049 1333 * @tc.desc: test DumpCatch API: PID(getpid), unsigned TID(0) 1334 * @tc.type: FUNC 1335 */ 1336HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest049, TestSize.Level2) 1337{ 1338 GTEST_LOG_(INFO) << "DumpCatcherSystemTest049: start."; 1339 std::atomic_int otherTid; 1340 std::atomic_bool done(false); 1341 std::thread th1([&otherTid, &done] { 1342 otherTid = gettid(); 1343 TestFunc1(&otherTid, &done); 1344 }); 1345 sleep(1); 1346 DfxDumpCatcher dumplog; 1347 string msg = ""; 1348 int32_t pid = getpid(); 1349 bool ret = dumplog.DumpCatch(pid, 0, msg); 1350 GTEST_LOG_(INFO) << "ret: " << ret; 1351 GTEST_LOG_(INFO) << "msg:\n" << msg; 1352 string log[] = {"#00", "test_faultloggerd", "Tid:", "Name", "Tid:"}; 1353 log[2].append(std::to_string(pid)); 1354 log[4].append(std::to_string(otherTid)); 1355 int logSize = sizeof(log) / sizeof(log[0]); 1356 int count = GetKeywordsNum(msg, log, logSize); 1357 GTEST_LOG_(INFO) << count; 1358 EXPECT_EQ(count, logSize) << "DumpCatcherSystemTest049 Failed"; 1359 done.store(true); 1360 th1.join(); 1361 GTEST_LOG_(INFO) << "DumpCatcherSystemTest049: end."; 1362} 1363 1364/** 1365 * @tc.name: DumpCatcherSystemTest101 1366 * @tc.desc: test using dumpcatcher command tools to dump the signal stop process 1367 * @tc.type: FUNC 1368 */ 1369HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest101, TestSize.Level2) 1370{ 1371 GTEST_LOG_(INFO) << "DumpCatcherSystemTest101: start uid:" << getuid(); 1372 pid_t pid = fork(); 1373 if (pid < 0) { 1374 FAIL() << "DumpCatcherSystemTest101: Failed to fork a test process"; 1375 } else if (pid == 0) { 1376 sleep(3); // 3 : sleep 3 seconds 1377 } 1378 kill(pid, SIGSTOP); 1379 string procCMD = "dumpcatcher -p " + to_string(pid); 1380 string procDumpLog = ExecuteCommands(procCMD); 1381 GTEST_LOG_(INFO) << "procDumpLog: " << procDumpLog; 1382 string log[] = { "Failed", "status:", "Name:", "nonvoluntary_ctxt_switches:", "wchan:", "Tid:" }; 1383 int count = GetKeywordsNum(procDumpLog, log, sizeof(log) / sizeof(log[0])); 1384 kill(pid, SIGKILL); 1385 EXPECT_EQ(count, sizeof(log) / sizeof(log[0])) << "DumpCatcherSystemTest101 Failed"; 1386 GTEST_LOG_(INFO) << "DumpCatcherSystemTest101: end."; 1387} 1388 1389/** 1390 * @tc.name: DumpCatcherSystemTest102 1391 * @tc.desc: test calling dumpcatcher interfaces to dump the signal stop process 1392 * @tc.type: FUNC 1393 */ 1394HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest102, TestSize.Level2) 1395{ 1396 GTEST_LOG_(INFO) << "DumpCatcherSystemTest102: start uid:" << getuid(); 1397 pid_t pid = fork(); 1398 if (pid < 0) { 1399 FAIL() << "DumpCatcherSystemTest102: Failed to fork a test process"; 1400 } else if (pid == 0) { 1401 sleep(3); // 3 : sleep 3 seconds 1402 } 1403 kill(pid, SIGSTOP); 1404 DfxDumpCatcher dumplog; 1405 string msg = ""; 1406 if (!dumplog.DumpCatch(pid, 0, msg)) { 1407 GTEST_LOG_(ERROR) << "DumpCatcherSystemTest102: Failed to dump target process."; 1408 } 1409 GTEST_LOG_(INFO) << msg; 1410 string log[] = { "timeout", "status:", "Name:", "nonvoluntary_ctxt_switches:", "wchan:", "Tid:" }; 1411 int count = GetKeywordsNum(msg, log, sizeof(log) / sizeof(log[0])); 1412 kill(pid, SIGKILL); 1413 EXPECT_EQ(count, sizeof(log) / sizeof(log[0])) << "DumpCatcherSystemTest102 Failed"; 1414 GTEST_LOG_(INFO) << "DumpCatcherSystemTest102: end."; 1415} 1416 1417static void TestDumpCatch(const int targetPid, const string& processName, const int threadIdx) 1418{ 1419 DfxDumpCatcher dumplog; 1420 string msg = ""; 1421 if (dumplog.DumpCatch(targetPid, 0, msg)) { 1422 GTEST_LOG_(INFO) << "threadIdx(" << threadIdx << ") dump sucessfully."; 1423 string log[] = {"Pid:" + to_string(targetPid), "Tid:" + to_string(targetPid), "Name:" + processName, 1424 "#00", "#01", "#02"}; 1425 int expectNum = sizeof(log) / sizeof(log[0]); 1426 int cnt = GetKeywordsNum(msg, log, sizeof(log) / sizeof(log[0])); 1427 EXPECT_EQ(cnt, expectNum) << "Check stack trace key words failed."; 1428 if (cnt == expectNum) { 1429 g_checkCnt++; 1430 } 1431 } else { 1432 GTEST_LOG_(INFO) << "threadIdx(" << threadIdx << ") dump failed."; 1433 if (msg.find("Result: pid(" + to_string(targetPid) + ") is dumping.") == string::npos) { 1434 GTEST_LOG_(ERROR) << "threadIdx(" << threadIdx << ") dump error message is unexpectly."; 1435 FAIL(); 1436 } 1437 } 1438} 1439 1440/** 1441* @tc.name: DumpCatcherSystemTest201 1442* @tc.desc: Calling DumpCatch Func for same process in multiple threads at same time 1443* @tc.type: FUNC 1444*/ 1445HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest201, TestSize.Level2) 1446{ 1447 GTEST_LOG_(INFO) << "DumpCatcherSystemTest201: start."; 1448 int accountmgrPid = GetProcessPid(ACCOUNTMGR_NAME); 1449 g_checkCnt = 0; 1450 for (int threadIdx = 0; threadIdx < MULTITHREAD_TEST_COUNT; threadIdx++) { 1451 thread(TestDumpCatch, accountmgrPid, ACCOUNTMGR_NAME, threadIdx).detach(); 1452 } 1453 sleep(2); // 2 : sleep 2 seconds 1454 EXPECT_GT(g_checkCnt, 0) << "DumpCatcherSystemTest201 failed"; 1455 GTEST_LOG_(INFO) << "DumpCatcherSystemTest201: end."; 1456} 1457 1458/** 1459* @tc.name: DumpCatcherSystemTest202 1460* @tc.desc: Calling DumpCatch Func for different process in multiple threads at same time 1461* @tc.type: FUNC 1462*/ 1463HWTEST_F(DumpCatcherSystemTest, DumpCatcherSystemTest202, TestSize.Level2) 1464{ 1465 GTEST_LOG_(INFO) << "DumpCatcherSystemTest202: start."; 1466 vector<string> testProcessNameVecs = {ACCOUNTMGR_NAME, FOUNDATION_NAME, APPSPAWN_NAME}; 1467 vector<int> testPidVecs; 1468 for (auto processName : testProcessNameVecs) { 1469 testPidVecs.emplace_back(GetProcessPid(processName)); 1470 } 1471 g_checkCnt = 0; 1472 auto testProcessListSize = testProcessNameVecs.size(); 1473 for (auto idx = 0; idx < testProcessListSize; idx++) { 1474 thread(TestDumpCatch, testPidVecs[idx], testProcessNameVecs[idx], idx).detach(); 1475 } 1476 sleep(2); // 2 : sleep 2 seconds 1477 EXPECT_EQ(g_checkCnt, 3) << "DumpCatcherSystemTest202 failed"; 1478 GTEST_LOG_(INFO) << "DumpCatcherSystemTest202: end."; 1479} 1480} // namespace HiviewDFX 1481} // namespace OHOS 1482