1/* 2 * Copyright (c) 2021-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 <cerrno> 17#include <fstream> 18#include <gtest/gtest.h> 19#include <map> 20#include <securec.h> 21#include <string> 22#include <sys/mman.h> 23#include <thread> 24#include <unistd.h> 25#include <vector> 26 27#include "dfx_test_util.h" 28#include "directory_ex.h" 29#include "dfx_define.h" 30#include "dfx_util.h" 31#include "procinfo.h" 32 33using namespace testing::ext; 34using namespace std; 35 36#define NSPID_PATH "/data/nspid" 37 38namespace OHOS { 39namespace HiviewDFX { 40class FaultLoggerdSystemTest : public testing::Test { 41public: 42 static void SetUpTestCase(void); 43 static void TearDownTestCase(void); 44 void SetUp(); 45 void TearDown(); 46}; 47 48void FaultLoggerdSystemTest::SetUpTestCase(void) 49{ 50 chmod("/data/crasher_c", 0755); // 0755 : -rwxr-xr-x 51 chmod("/data/crasher_cpp", 0755); // 0755 : -rwxr-xr-x 52} 53 54void FaultLoggerdSystemTest::TearDownTestCase(void) 55{ 56} 57 58void FaultLoggerdSystemTest::SetUp(void) 59{ 60} 61 62void FaultLoggerdSystemTest::TearDown(void) 63{ 64} 65 66namespace { 67static const int CPPCRASH_FILENAME_MIN_LENGTH = 36; // 36 : length of /data/log/faultlog/temp/cppcrash-x-x 68static const int SIGNAL_TEST_NUM = 50; 69} 70 71static pid_t ForkAndExecuteCrasher(const string& option, const CrasherType type) 72{ 73 pid_t pid = fork(); 74 if (pid < 0) { 75 GTEST_LOG_(ERROR) << "Fork failed"; 76 return pid; 77 } else if (pid == 0) { 78 if (type == CRASHER_C) { 79 execl("/data/crasher_c", "crasher_c", option.c_str(), nullptr); 80 } else { 81 execl("/data/crasher_cpp", "crasher_cpp", option.c_str(), nullptr); 82 } 83 } 84 85 GTEST_LOG_(INFO) << "forked pid:" << pid; 86 constexpr time_t maxWaitingTime = 60; // 60 : 60s timeout 87 time_t remainedTime = maxWaitingTime; 88 while (remainedTime > 0) { 89 time_t startTime = time(nullptr); 90 int status = 0; 91 waitpid(pid, &status, WNOHANG); 92 if (WIFEXITED(status)) { 93 break; 94 } 95 sleep(1); 96 time_t duration = time(nullptr) - startTime; 97 remainedTime = (remainedTime > duration) ? (remainedTime - duration) : 0; 98 } 99 return pid; 100} 101 102static pid_t TriggerCrasherAndGetFileName(const string& option, const CrasherType type, string& crashFileName, 103 int waitSec = 1, const std::string& tempPath = TEMP_DIR) 104{ 105 auto pid = ForkAndExecuteCrasher(option, type); 106 int recheckCount = 0; 107 108 // 6: means recheck times 109 while (recheckCount < 6) { 110 sleep(waitSec); 111 crashFileName = GetCppCrashFileName(pid, tempPath); 112 if (crashFileName.size() > 0) { 113 GTEST_LOG_(INFO) << "get crash file:" << crashFileName; 114 break; 115 } 116 GTEST_LOG_(INFO) << "recheck crash file, pid" << pid; 117 recheckCount++; 118 } 119 return pid; 120} 121 122static bool CheckCountNum(const string& filePath, const pid_t& pid, const string& option) 123{ 124 map<string, string> optionReasonMap = { 125#if defined(__LP64__) 126 { string("triSIGTRAP"), string("SIGILL") }, 127#else 128 { string("triSIGTRAP"), string("SIGTRAP") }, 129#endif 130 { string("triSIGILL"), string("SIGILL") }, 131 { string("triSIGSEGV"), string("SIGSEGV") }, 132 { string("MaxStack"), string("SIGSEGV") }, 133 { string("MaxMethod"), string("SIGSEGV") }, 134 { string("STACKOF"), string("SIGSEGV") }, 135 { string("OOM"), string("SIGABRT") }, 136 }; 137 string reason = option; 138 auto iter = optionReasonMap.find(option); 139 if (iter != optionReasonMap.end()) { 140 GTEST_LOG_(INFO) << "optionReasonMap matched"; 141 reason = iter->second; 142 } 143 string log[] = { 144 "Pid:" + to_string(pid), "Uid", ":crasher", reason, "Tid:", "#00", "Registers:", REGISTERS, "FaultStack:", 145 "Maps:", "/crasher" 146 }; 147 int minRegIdx = 6; // 6 : index of first REGISTERS - 1 148 int expectNum = sizeof(log) / sizeof(log[0]); 149 return CheckKeyWords(filePath, log, expectNum, minRegIdx) == expectNum; 150} 151 152static bool CheckCountNumAbort(const string& filePath, const pid_t& pid) 153{ 154 string log[] = { 155 "Pid:" + to_string(pid), "Uid", ":crasher", "SIGABRT", "LastFatalMessage:", "ABORT!", "Tid:", "#00", 156 "Registers:", REGISTERS, "FaultStack:", "Maps:", "/crasher" 157 }; 158 int minRegIdx = 8; // 8 : index of first REGISTERS - 1 159 int expectNum = sizeof(log) / sizeof(log[0]); 160 return CheckKeyWords(filePath, log, expectNum, minRegIdx) == expectNum; 161} 162 163 164static bool CheckCountNumNullpointer(const string& filePath, const pid_t& pid) 165{ 166 string log[] = { 167 "Pid:" + to_string(pid), "Uid", ":crasher", "SIGSEGV", "NULL", "pointer", "dereference", "Tid:", "#00", 168 "Registers:", REGISTERS, "FaultStack:", "Maps:", "/crasher" 169 }; 170 int minRegIdx = 9; // 7 : index of first REGISTERS - 1 171 int expectNum = sizeof(log) / sizeof(log[0]); 172 return CheckKeyWords(filePath, log, expectNum, minRegIdx) == expectNum; 173} 174 175static bool CheckCountNumStackOverFlow(const string& filePath, const pid_t& pid) 176{ 177 string log[] = { 178 "Pid:" + to_string(pid), "Uid", ":crasher", "SIGSEGV", "stack-buffer-overflow", "Tid:", "#00", 179 "Registers:", REGISTERS, "FaultStack:", "Maps:", "/crasher" 180 }; 181 int minRegIdx = 7; // 7 : index of first REGISTERS - 1 182 int expectNum = sizeof(log) / sizeof(log[0]); 183 return CheckKeyWords(filePath, log, expectNum, minRegIdx) == expectNum; 184} 185 186static bool CheckCountNumPCZero(const string& filePath, const pid_t& pid) 187{ 188 string log[] = { 189 "Pid:" + to_string(pid), "Uid", ":crasher", "SIGSEGV", "Tid:", "#00", "Registers:", REGISTERS, "FaultStack:", 190 "Maps:", "/crasher" 191 }; 192 int minRegIdx = 6; // 6 : index of first REGISTERS - 1 193 int expectNum = sizeof(log) / sizeof(log[0]); 194 return CheckKeyWords(filePath, log, expectNum, minRegIdx) == expectNum; 195} 196 197static bool CheckCountNumOverStack(const string& filePath, const pid_t& pid) 198{ 199 string log[] = { 200 "Pid:" + to_string(pid), "Uid", ":crasher", "SIGSEGV", "Tid:", "#56", "Registers:", REGISTERS, "FaultStack:", 201 "Maps:", "/crasher" 202 }; 203 int minRegIdx = 6; // 6 : index of first REGISTERS - 1 204 int expectNum = sizeof(log) / sizeof(log[0]); 205 return CheckKeyWords(filePath, log, expectNum, minRegIdx) == expectNum; 206} 207 208static bool CheckCountNumMultiThread(const string& filePath, const pid_t& pid) 209{ 210 string log[] = { 211 "Pid:" + to_string(pid), "Uid", ":crasher", "SIGSEGV", "Tid:", "#00", 212 "Registers:", REGISTERS, "FaultStack:", "Maps:", 213 "/crasher" 214 }; 215 int minRegIdx = 6; // 6 : index of first REGISTERS - 1 216 int expectNum = sizeof(log) / sizeof(log[0]); 217 return CheckKeyWords(filePath, log, expectNum, minRegIdx) == expectNum; 218} 219 220static string GetStackTop(void) 221{ 222 ifstream spFile; 223 spFile.open("/data/sp"); 224 string sp; 225 spFile >> sp; 226 spFile.close(); 227 int ret = remove("/data/sp"); 228 if (ret != 0) { 229 printf("remove failed!"); 230 } 231 int leftZero = REGISTER_FORMAT_LENGTH - sp.length(); 232 while (leftZero > 0) { 233 sp = "0" + sp; 234 leftZero--; 235 } 236 GTEST_LOG_(INFO) << "sp:" << sp; 237 return sp; 238} 239 240static void WriteRealPid(int realPid) 241{ 242 ofstream file; 243 file.open(NSPID_PATH); 244 file << std::to_string(realPid); 245 file.close(); 246} 247 248static int ReadRealPid(void) 249{ 250 ifstream file; 251 file.open(NSPID_PATH); 252 string pid; 253 file >> pid; 254 file.close(); 255 int ret = remove(NSPID_PATH); 256 if (ret != 0) { 257 printf("remove failed!"); 258 } 259 int realPid = atoi(pid.c_str()); 260 GTEST_LOG_(INFO) << "real pid:" << realPid; 261 return realPid; 262} 263 264static bool CheckCountNumStackTop(const string& filePath, const pid_t& pid) 265{ 266 string log[] = { 267 "Pid:" + to_string(pid), "Uid", ":crasher", "SIGSEGV", "Tid:", "#00", "Registers:", REGISTERS, "FaultStack:", 268 "Maps:", "/crasher" 269 }; 270 string sp = GetStackTop(); 271 for (auto& keyword : log) { 272 if (keyword == "sp:") { 273 keyword += sp; 274 } 275 } 276 int minRegIdx = 6; // 6 : index of first REGISTERS - 1 277 int expectNum = sizeof(log) / sizeof(log[0]); 278 return CheckKeyWords(filePath, log, expectNum, minRegIdx) == expectNum; 279} 280 281static bool CheckCppCrashAllLabelKeywords(const string& filePath, const pid_t& pid) 282{ 283 string log[] = { 284 "Timestamp:", "Pid:" + to_string(pid), "Uid:", "Process", "Reason:", "LastFatalMessage:", "Fault", "thread", 285 "info:", "Tid:", "#00", "Registers:", REGISTERS, "Memory", "near", "registers:", "FaultStack:", "Maps:", 286 "/crasher" 287 }; 288 int minRegIdx = 11; // 11 : index of first REGISTERS - 1 289 int expectNum = sizeof(log) / sizeof(log[0]); 290 return CheckKeyWords(filePath, log, expectNum, minRegIdx) == expectNum; 291} 292 293#if defined(__aarch64__) 294static bool CheckCppCrashAsyncStackEnableKeywords(const string& filePath, const pid_t& pid) 295{ 296 string log[] = { 297 "Timestamp:", "Pid:" + to_string(pid), "Uid:", "Process", "Reason:", "Fault", "thread", "info:", 298 "Tid:", "#00", "SubmitterStacktrace", "Registers:", REGISTERS, "Memory", "near", "registers:", 299 "FaultStack:", "Maps:", "/crasher" 300 }; 301 int minRegIdx = 11; // 11 : index of first REGISTERS - 1 302 int expectNum = sizeof(log) / sizeof(log[0]); 303 return CheckKeyWords(filePath, log, expectNum, minRegIdx) == expectNum; 304} 305 306static bool CheckCppCrashAsyncStackDisableKeywords(const string& filePath, const pid_t& pid) 307{ 308 string log[] = { 309 "Timestamp:", "Pid:" + to_string(pid), "Uid:", "Process", "Reason:", "Fault", "thread", "info:", 310 "Tid:", "#00", "Registers:", REGISTERS, "Memory", "near", "registers:", 311 "FaultStack:", "Maps:", "/crasher" 312 }; 313 int minRegIdx = 10; // 10 : index of first REGISTERS - 1 314 int expectNum = sizeof(log) / sizeof(log[0]); 315 if (CheckKeyWords(filePath, log, expectNum, minRegIdx) != expectNum) { 316 return false; 317 } 318 string key[] = { 319 "SubmitterStacktrace" 320 }; 321 return CheckKeyWords(filePath, key, 1, -1) == 0; 322} 323 324static bool CheckTestGetCrashObj(const string& filePath, const pid_t& pid) 325{ 326 string log[] = { 327 "Pid:" + to_string(pid), "Uid", ":crasher", "SIGABRT", "LastFatalMessage:", "crashObject.", 328 "Tid:", "#00", "Registers:", REGISTERS, "FaultStack:", "Maps:", "/crasher" 329 }; 330 int minRegIdx = 8; // 8 : index of first REGISTERS - 1 331 int expectNum = sizeof(log) / sizeof(log[0]); 332 return CheckKeyWords(filePath, log, expectNum, minRegIdx) == expectNum; 333} 334#endif 335 336/** 337 * @tc.name: FaultLoggerdSystemTest001 338 * @tc.desc: test C crasher application: SIGFPE 339 * @tc.type: FUNC 340 */ 341HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest001, TestSize.Level2) 342{ 343 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest001: start."; 344 string cmd = "SIGFPE"; 345 string fileName; 346 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 347 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 348 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 349 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 350 FAIL(); 351 } 352 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "ProcessDfxRequestTest001 Failed"; 353 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest001: end."; 354} 355 356/** 357 * @tc.name: FaultLoggerdSystemTest002 358 * @tc.desc: test CPP crasher application: SIGFPE 359 * @tc.type: FUNC 360 */ 361HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest002, TestSize.Level2) 362{ 363 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest002: start."; 364 string cmd = "SIGFPE"; 365 string fileName; 366 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 367 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 368 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 369 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 370 FAIL(); 371 } 372 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest002 Failed"; 373 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest002: end."; 374} 375 376/** 377 * @tc.name: FaultLoggerdSystemTest003 378 * @tc.desc: test C crasher application: SIGILL 379 * @tc.type: FUNC 380 */ 381HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest003, TestSize.Level2) 382{ 383 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest003: start."; 384 string cmd = "SIGILL"; 385 string fileName; 386 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 387 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 388 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 389 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 390 FAIL(); 391 } 392 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest003 Failed"; 393 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest003: end."; 394} 395 396/** 397 * @tc.name: FaultLoggerdSystemTest004 398 * @tc.desc: test CPP crasher application: SIGILL 399 * @tc.type: FUNC 400 */ 401HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest004, TestSize.Level2) 402{ 403 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest004: start."; 404 string cmd = "SIGILL"; 405 string fileName; 406 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 407 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 408 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 409 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 410 FAIL(); 411 } 412 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest004 Failed"; 413 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest004: end."; 414} 415 416/** 417* @tc.name: FaultLoggerdSystemTest005 418* @tc.desc: test C crasher application: triSIGILL 419* @tc.type: FUNC 420*/ 421HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest005, TestSize.Level2) 422{ 423 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest005: start."; 424 string cmd = "triSIGILL"; 425 string fileName; 426 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 427 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 428 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 429 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 430 FAIL(); 431 } 432 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest005 Failed"; 433 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest005: end."; 434} 435 436/** 437* @tc.name: FaultLoggerdSystemTest006 438* @tc.desc: test CPP crasher application: triSIGILL 439* @tc.type: FUNC 440*/ 441HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest006, TestSize.Level2) 442{ 443 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest006: start."; 444 string cmd = "triSIGILL"; 445 string fileName; 446 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 447 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 448 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 449 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 450 FAIL(); 451 } 452 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest006 Failed"; 453 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest006: end."; 454} 455 456/** 457 * @tc.name: FaultLoggerdSystemTest007 458 * @tc.desc: test C crasher application: SIGSEGV 459 * @tc.type: FUNC 460 */ 461HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest007, TestSize.Level2) 462{ 463 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest007: start."; 464 string cmd = "SIGSEGV"; 465 string fileName; 466 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 467 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 468 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 469 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 470 FAIL(); 471 } 472 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest007 Failed"; 473 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest007: end."; 474} 475 476/** 477 * @tc.name: FaultLoggerdSystemTest008 478 * @tc.desc: test CPP crasher application: SIGSEGV 479 * @tc.type: FUNC 480 */ 481HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest008, TestSize.Level2) 482{ 483 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest008: start."; 484 string cmd = "SIGSEGV"; 485 string fileName; 486 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 487 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 488 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 489 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 490 FAIL(); 491 } 492 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest008 Failed"; 493 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest008: end."; 494} 495 496/** 497* @tc.name: FaultLoggerdSystemTest009 498* @tc.desc: test C crasher application: triSIGSEGV 499* @tc.type: FUNC 500*/ 501HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest009, TestSize.Level2) 502{ 503 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest009: start."; 504 string cmd = "triSIGSEGV"; 505 string fileName; 506 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 507 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 508 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 509 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 510 FAIL(); 511 } 512 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest009 Failed"; 513 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest009: end."; 514} 515 516/** 517* @tc.name: FaultLoggerdSystemTest010 518* @tc.desc: test CPP crasher application: triSIGSEGV 519* @tc.type: FUNC 520*/ 521HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest010, TestSize.Level2) 522{ 523 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest010: start."; 524 string cmd = "triSIGSEGV"; 525 string fileName; 526 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 527 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 528 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 529 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 530 FAIL(); 531 } 532 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest010 Failed"; 533 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest010: end."; 534} 535 536/** 537 * @tc.name: FaultLoggerdSystemTest011 538 * @tc.desc: test C crasher application: SIGTRAP 539 * @tc.type: FUNC 540 */ 541HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest011, TestSize.Level2) 542{ 543 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest011: start."; 544 string cmd = "SIGTRAP"; 545 string fileName; 546 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 547 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 548 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 549 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 550 FAIL(); 551 } 552 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest011 Failed"; 553 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest011: end."; 554} 555 556/** 557 * @tc.name: FaultLoggerdSystemTest012 558 * @tc.desc: test CPP crasher application: SIGTRAP 559 * @tc.type: FUNC 560 */ 561HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest012, TestSize.Level2) 562{ 563 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest012: start."; 564 string cmd = "SIGTRAP"; 565 string fileName; 566 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 567 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 568 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 569 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 570 FAIL(); 571 } 572 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest012 Failed"; 573 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest012: end."; 574} 575 576/** 577* @tc.name: FaultLoggerdSystemTest013 578* @tc.desc: test C crasher application: triSIGTRAP 579* @tc.type: FUNC 580*/ 581HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest013, TestSize.Level2) 582{ 583 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest013: start."; 584 string cmd = "triSIGTRAP"; 585 string fileName; 586 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 587 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 588 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 589 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 590 FAIL(); 591 } 592 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest013 Failed"; 593 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest013: end."; 594} 595 596/** 597* @tc.name: FaultLoggerdSystemTest014 598* @tc.desc: test CPP crasher application: triSIGTRAP 599* @tc.type: FUNC 600*/ 601HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest014, TestSize.Level2) 602{ 603 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest014: start."; 604 string cmd = "triSIGTRAP"; 605 string fileName; 606 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 607 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 608 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 609 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 610 FAIL(); 611 } 612 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest014 Failed"; 613 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest014: end."; 614} 615 616/** 617 * @tc.name: FaultLoggerdSystemTest015 618 * @tc.desc: test C crasher application: SIGABRT 619 * @tc.type: FUNC 620 */ 621HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest015, TestSize.Level2) 622{ 623 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest015: start."; 624 string cmd = "SIGABRT"; 625 string fileName; 626 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 627 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 628 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 629 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 630 FAIL(); 631 } 632 EXPECT_TRUE(CheckCountNumAbort(fileName, pid)) << "FaultLoggerdSystemTest015 Failed"; 633 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest015: end."; 634} 635 636/** 637 * @tc.name: FaultLoggerdSystemTest016 638 * @tc.desc: test CPP crasher application: SIGABRT 639 * @tc.type: FUNC 640 */ 641HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest016, TestSize.Level2) 642{ 643 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest016: start."; 644 string cmd = "SIGABRT"; 645 string fileName; 646 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 647 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 648 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 649 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 650 FAIL(); 651 } 652 EXPECT_TRUE(CheckCountNumAbort(fileName, pid)) << "FaultLoggerdSystemTest016 Failed"; 653 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest016: end."; 654} 655 656/** 657* @tc.name: FaultLoggerdSystemTest017 658* @tc.desc: test C crasher application: triSIGABRT 659* @tc.type: FUNC 660*/ 661HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest017, TestSize.Level2) 662{ 663 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest017: start."; 664 string cmd = "triSIGABRT"; 665 string fileName; 666 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 667 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 668 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 669 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 670 FAIL(); 671 } 672 EXPECT_TRUE(CheckCountNumAbort(fileName, pid)) << "FaultLoggerdSystemTest017 Failed"; 673 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest017: end."; 674} 675 676/** 677* @tc.name: FaultLoggerdSystemTest018 678* @tc.desc: test CPP crasher application: triSIGABRT 679* @tc.type: FUNC 680*/ 681HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest018, TestSize.Level2) 682{ 683 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest018: start."; 684 string cmd = "triSIGABRT"; 685 string fileName; 686 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 687 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 688 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 689 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 690 FAIL(); 691 } 692 EXPECT_TRUE(CheckCountNumAbort(fileName, pid)) << "FaultLoggerdSystemTest018 Failed"; 693 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest018: end."; 694} 695 696/** 697* @tc.name: FaultLoggerdSystemTest019 698* @tc.desc: test C crasher application: SIGBUS 699* @tc.type: FUNC 700*/ 701HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest019, TestSize.Level2) 702{ 703 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest019: start."; 704 string cmd = "SIGBUS"; 705 string fileName; 706 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 707 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 708 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 709 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 710 FAIL(); 711 } 712 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest019 Failed"; 713 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest019: end."; 714} 715 716/** 717* @tc.name: FaultLoggerdSystemTest020 718* @tc.desc: test CPP crasher application: SIGBUS 719* @tc.type: FUNC 720*/ 721HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest020, TestSize.Level2) 722{ 723 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest020: start."; 724 string cmd = "SIGBUS"; 725 string fileName; 726 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 727 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 728 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 729 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 730 FAIL(); 731 } 732 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest020 Failed"; 733 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest020: end."; 734} 735 736/** 737* @tc.name: FaultLoggerdSystemTest021 738* @tc.desc: test C crasher application: MaxStack 739* @tc.type: FUNC 740*/ 741HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest021, TestSize.Level2) 742{ 743 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest021: start."; 744 string cmd = "MaxStack"; 745 string fileName; 746 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 747 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 748 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 749 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 750 FAIL(); 751 } 752 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest021 Failed"; 753 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest021: end."; 754} 755 756/** 757* @tc.name: FaultLoggerdSystemTest022 758* @tc.desc: test CPPcrasher application: MaxStack 759* @tc.type: FUNC 760*/ 761HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest022, TestSize.Level2) 762{ 763 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest022: start."; 764 string cmd = "MaxStack"; 765 string fileName; 766 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 767 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 768 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 769 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 770 FAIL(); 771 } 772 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest022 Failed"; 773 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest022: end."; 774} 775 776/** 777* @tc.name: FaultLoggerdSystemTest023 778* @tc.desc: test C crasher application: MaxMethod 779* @tc.type: FUNC 780*/ 781HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest023, TestSize.Level2) 782{ 783 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest023: start."; 784 string cmd = "MaxMethod"; 785 string fileName; 786 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 787 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 788 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 789 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 790 FAIL(); 791 } 792 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest023 Failed"; 793 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest023: end."; 794} 795 796/** 797* @tc.name: FaultLoggerdSystemTest024 798* @tc.desc: test CPP crasher application: MaxMethod 799* @tc.type: FUNC 800*/ 801HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest024, TestSize.Level2) 802{ 803 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest024: start."; 804 string cmd = "MaxMethod"; 805 string fileName; 806 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 807 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 808 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 809 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 810 FAIL(); 811 } 812 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest024 Failed"; 813 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest024: end."; 814} 815 816/** 817* @tc.name: FaultLoggerdSystemTest025 818* @tc.desc: test C crasher application: STACKOF 819* @tc.type: FUNC 820*/ 821HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest025, TestSize.Level2) 822{ 823 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest025: start."; 824 string cmd = "STACKOF"; 825 string fileName; 826 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 827 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 828 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 829 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 830 FAIL(); 831 } 832 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest025 Failed"; 833 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest025: end."; 834} 835 836/** 837* @tc.name: FaultLoggerdSystemTest026 838* @tc.desc: test CPP crasher application: STACKOF 839* @tc.type: FUNC 840*/ 841HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest026, TestSize.Level2) 842{ 843 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest026: start."; 844 string cmd = "STACKOF"; 845 string fileName; 846 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 847 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 848 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 849 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 850 FAIL(); 851 } 852 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest026 Failed"; 853 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest026: end."; 854} 855 856/** 857 * @tc.name: FaultLoggerdSystemTest027 858 * @tc.desc: test CPP crasher application: OOM 859 * @tc.type: FUNC 860 */ 861HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest027, TestSize.Level2) 862{ 863 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest027: start."; 864 string cmd = "OOM"; 865 string fileName; 866 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 867 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 868 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 869 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 870 FAIL(); 871 } 872 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest027 Failed"; 873 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest027: end."; 874} 875 876/** 877 * @tc.name: FaultLoggerdSystemTest028 878 * @tc.desc: test C crasher application: OOM 879 * @tc.type: FUNC 880 */ 881HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest028, TestSize.Level2) 882{ 883 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest028: start."; 884 string cmd = "OOM"; 885 string fileName; 886 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 887 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 888 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 889 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 890 FAIL(); 891 } 892 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest028 Failed"; 893 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest028: end."; 894} 895/** 896 * @tc.name: FaultLoggerdSystemTest029 897 * @tc.desc: test CPP crasher application: PCZero 898 * @tc.type: FUNC 899 */ 900HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest029, TestSize.Level2) 901{ 902 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest029: start."; 903 string cmd = "PCZero"; 904 string fileName; 905 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 906 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 907 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 908 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 909 FAIL(); 910 } 911 EXPECT_TRUE(CheckCountNumPCZero(fileName, pid)) << "FaultLoggerdSystemTest029 Failed"; 912 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest029: end."; 913} 914 915/** 916 * @tc.name: FaultLoggerdSystemTest030 917 * @tc.desc: test C crasher application: PCZero 918 * @tc.type: FUNC 919 */ 920HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest030, TestSize.Level2) 921{ 922 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest030: start."; 923 string cmd = "PCZero"; 924 string fileName; 925 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 926 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 927 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 928 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 929 FAIL(); 930 } 931 EXPECT_TRUE(CheckCountNumPCZero(fileName, pid)) << "FaultLoggerdSystemTest030 Failed"; 932 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest030: end."; 933} 934 935/** 936 * @tc.name: FaultLoggerdSystemTest031 937 * @tc.desc: test C crasher application: MTCrash 938 * @tc.type: FUNC 939 */ 940HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest031, TestSize.Level2) 941{ 942 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest031: start."; 943 string cmd = "MTCrash"; 944 string fileName; 945 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName, 2); // 2 : sleep 2s for waiting cppcrash file 946 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 947 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 948 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 949 FAIL(); 950 } 951 EXPECT_TRUE(CheckCountNumMultiThread(fileName, pid)) << "FaultLoggerdSystemTest031 Failed"; 952 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest031: end."; 953} 954 955/** 956 * @tc.name: FaultLoggerdSystemTest032 957 * @tc.desc: test CPP crasher application: MTCrash 958 * @tc.type: FUNC 959 */ 960HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest032, TestSize.Level2) 961{ 962 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest032: start."; 963 string cmd = "MTCrash"; 964 string fileName; 965 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName, 2); // 2 : sleep 2s for waiting cppcrash file 966 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 967 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 968 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 969 FAIL(); 970 } 971 EXPECT_TRUE(CheckCountNumMultiThread(fileName, pid)) << "FaultLoggerdSystemTest032 Failed"; 972 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest032: end."; 973} 974 975/** 976 * @tc.name: FaultLoggerdSystemTest033 977 * @tc.desc: test CPP crasher application: StackOver64 978 * @tc.type: FUNC 979 */ 980HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest033, TestSize.Level2) 981{ 982 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest033: start."; 983 string cmd = "StackOver64"; 984 string fileName; 985 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 986 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 987 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 988 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 989 FAIL(); 990 } 991 EXPECT_TRUE(CheckCountNumOverStack(fileName, pid)) << "FaultLoggerdSystemTest033 Failed"; 992 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest033: end."; 993} 994 995/** 996 * @tc.name: FaultLoggerdSystemTest034 997 * @tc.desc: test C crasher application: StackOver64 998 * @tc.type: FUNC 999 */ 1000HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest034, TestSize.Level2) 1001{ 1002 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest034: start."; 1003 string cmd = "StackOver64"; 1004 string fileName; 1005 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 1006 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1007 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1008 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1009 FAIL(); 1010 } 1011 EXPECT_TRUE(CheckCountNumOverStack(fileName, pid)) << "FaultLoggerdSystemTest034 Failed"; 1012 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest034: end."; 1013} 1014 1015/** 1016 * @tc.name: FaultLoggerdSystemTest035 1017 * @tc.desc: test C crasher application: StackTop 1018 * @tc.type: FUNC 1019 */ 1020HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest035, TestSize.Level2) 1021{ 1022 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest035: start."; 1023 string cmd = "StackTop"; 1024 string fileName; 1025 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 1026 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1027 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1028 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1029 FAIL(); 1030 } 1031 EXPECT_TRUE(CheckCountNumStackTop(fileName, pid)) << "FaultLoggerdSystemTest035 Failed"; 1032 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest035: end."; 1033} 1034 1035/** 1036 * @tc.name: FaultLoggerdSystemTest036 1037 * @tc.desc: test CPP crasher application: StackTop 1038 * @tc.type: FUNC 1039 */ 1040HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest036, TestSize.Level2) 1041{ 1042 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest036: start."; 1043 string cmd = "StackTop"; 1044 string fileName; 1045 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 1046 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1047 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1048 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1049 FAIL(); 1050 } 1051 EXPECT_TRUE(CheckCountNumStackTop(fileName, pid)) << "FaultLoggerdSystemTest036 Failed"; 1052 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest036: end."; 1053} 1054 1055void GenerateCrashLogFiles() 1056{ 1057 for (int i = 0; i < SIGNAL_TEST_NUM; i++) { 1058 system("/data/crasher_c CrashTest &"); 1059 } 1060 sleep(10); // 10 : sleep for 10 seconds 1061} 1062 1063/** 1064 * @tc.name: FaultLoggerdSystemTest101 1065 * @tc.desc: test C crasher application: 50 Abnormal signal 1066 * @tc.type: FUNC 1067 */ 1068HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest101, TestSize.Level2) 1069{ 1070 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest0009: start."; 1071 string clearTempFilesCmd = "rm -rf /data/log/faultlog/temp/*"; 1072 system(clearTempFilesCmd.c_str()); 1073 GenerateCrashLogFiles(); 1074 vector<string> files; 1075 OHOS::GetDirFiles("/data/log/faultlog/temp/", files); 1076 GTEST_LOG_(INFO) << files.size(); 1077 EXPECT_EQ(files.size(), SIGNAL_TEST_NUM) << "FaultLoggerdSystemTest101 Failed"; 1078} 1079 1080static void CrashInChildThread() 1081{ 1082 GTEST_LOG_(INFO) << "CrashInChildThread(): TID = " << gettid(); 1083 raise(SIGSEGV); 1084} 1085 1086static int RunInNewPidNs(void* arg) 1087{ 1088 (void)arg; 1089 struct ProcInfo g_nsProcInfo; 1090 GetProcStatus(g_nsProcInfo); 1091 WriteRealPid(g_nsProcInfo.pid); 1092 GTEST_LOG_(INFO) << "RunInNewPidNs(): real pid = " << g_nsProcInfo.pid; 1093 GTEST_LOG_(INFO) << "RunInNewPidNs(): PID = " << getpid(); 1094 GTEST_LOG_(INFO) << "RunInNewPidNs(): TID = " << gettid(); 1095 thread childThread(CrashInChildThread); 1096 childThread.join(); 1097 _exit(0); 1098} 1099 1100/** 1101 * @tc.name: FaultLoggerdSystemTest102 1102 * @tc.desc: test crash in process with pid namespace 1103 * @tc.type: FUNC 1104 */ 1105HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest102, TestSize.Level2) 1106{ 1107 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest102: start."; 1108 const int stackSz = 1024 * 1024 * 1024; // 1M 1109 void* cloneStack = mmap(nullptr, stackSz, 1110 PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, 1, 0); 1111 if (cloneStack == nullptr) { 1112 FAIL(); 1113 } 1114 cloneStack = static_cast<void *>(static_cast<uint8_t *>(cloneStack) + stackSz - 1); 1115 int childPid = clone(RunInNewPidNs, cloneStack, CLONE_NEWPID | SIGCHLD, nullptr); 1116 bool isSuccess = childPid > 0; 1117 if (!isSuccess) { 1118 ASSERT_FALSE(isSuccess); 1119 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest102: Failed to clone new process. errno:" << errno; 1120 return; 1121 } 1122 // wait for log generation 1123 sleep(3); // 3 : sleep 3s 1124 int readPid = ReadRealPid(); 1125 string fileName = GetCppCrashFileName(readPid); 1126 EXPECT_NE(0, fileName.size()); 1127 printf("PidNs Crash File:%s\n", fileName.c_str()); 1128 string log[] = { 1129 "Pid:", "Uid", "SIGSEGV", "Tid:", "#00", 1130 "Registers:", REGISTERS, "FaultStack:", "Maps:" 1131 }; 1132 int minRegIdx = 5; // 5 : index of first REGISTERS - 1 1133 int expectNum = sizeof(log) / sizeof(log[0]); 1134 int count = CheckKeyWords(fileName, log, expectNum, minRegIdx); 1135 EXPECT_EQ(count, expectNum); 1136 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest102: end."; 1137} 1138 1139/** 1140 * @tc.name: FaultLoggerdSystemTest103 1141 * @tc.desc: test the aging mechanism of the temp directory 1142 * @tc.type: FUNC 1143 */ 1144HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest103, TestSize.Level2) 1145{ 1146 string clearTempFilesCmd = "rm -rf /data/log/faultlog/temp/*"; 1147 system(clearTempFilesCmd.c_str()); 1148 system("/data/crasher_c SIGSEGV"); // trigger aging mechanism 1149 sleep(1); // 1 : sleep for 1 seconds 1150 vector<string> files; 1151 OHOS::GetDirFiles("/data/log/faultlog/temp/", files); 1152 string oldcrash = ""; 1153 if (!files.empty()) { 1154 oldcrash = files[0]; 1155 } 1156 GTEST_LOG_(INFO) << oldcrash; 1157 files.clear(); 1158 for (int i = 0; i < 25; i++) { // 25 : the count of crash file 1159 system("/data/crasher_c SIGSEGV"); 1160 } 1161 for (int i = 0; i < 25; i++) { // 25 : the count of crash file 1162 sleep(3); //3 : sleep for 3 seconds 1163 system("/data/crasher_c SIGSEGV"); 1164 } 1165 OHOS::GetDirFiles("/data/log/faultlog/temp/", files); 1166 for (size_t i = 0; i < files.size(); i++) { 1167 if (files[i] == oldcrash) { 1168 FAIL(); 1169 } 1170 } 1171 int fileCount = files.size(); 1172 GTEST_LOG_(INFO) << fileCount; 1173 system("/data/crasher_c SIGSEGV"); // trigger aging mechanism 1174 sleep(1); // 1 : sleep for 1 seconds 1175 files.clear(); 1176 OHOS::GetDirFiles("/data/log/faultlog/temp/", files); 1177 EXPECT_EQ(fileCount, files.size()) << "FaultLoggerdSystemTest103 Failed"; 1178} 1179 1180/** 1181 * @tc.name: FaultLoggerdSystemTest0104 1182 * @tc.desc: test crash log build-id 1183 * @tc.type: FUNC 1184 */ 1185HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest104, TestSize.Level2) 1186{ 1187 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest104: start."; 1188 string cmd = "SIGSEGV"; 1189 string fileName; 1190 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 1191 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1192 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1193 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1194 FAIL(); 1195 } 1196 std::ifstream file; 1197 file.open(fileName.c_str(), std::ios::in); 1198 while (!file.eof()) { 1199 string s; 1200 file >> s; 1201 if (s.find("/data/crasher_c") != string::npos) { 1202 string buildId; 1203 size_t leftBraceIdx = s.find('('); 1204 size_t rightBraceIdx = s.find(')'); 1205 if (leftBraceIdx != string::npos && rightBraceIdx != string::npos) { 1206 buildId = s.substr(leftBraceIdx + 1, rightBraceIdx - leftBraceIdx - 1); 1207 GTEST_LOG_(INFO) << "build-id = " << buildId; 1208 } 1209 EXPECT_FALSE(buildId.empty()) << "FaultLoggerdSystemTest104 Failed"; 1210 break; 1211 } 1212 } 1213 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest104: end."; 1214} 1215 1216/** 1217 * @tc.name: FaultLoggerdSystemTest105 1218 * @tc.desc: test C crasher application: SIGABRT, and check all label keywords 1219 * @tc.type: FUNC 1220 */ 1221HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest105, TestSize.Level2) 1222{ 1223 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest105: start."; 1224 string cmd = "SIGABRT"; 1225 string fileName; 1226 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 1227 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1228 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1229 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1230 FAIL(); 1231 } 1232 EXPECT_TRUE(CheckCppCrashAllLabelKeywords(fileName, pid)) << "FaultLoggerdSystemTest105 Failed"; 1233 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest105: end."; 1234} 1235 1236/** 1237 * @tc.name: FaultLoggerdSystemTest106 1238 * @tc.desc: test CPP crasher application: NullPointerDeref0 1239 * @tc.type: FUNC 1240 */ 1241HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest106, TestSize.Level2) 1242{ 1243 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest106: start."; 1244 string cmd = "NullPointerDeref0"; 1245 string fileName; 1246 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 1247 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1248 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1249 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1250 FAIL(); 1251 } 1252 EXPECT_TRUE(CheckCountNumNullpointer(fileName, pid)) << "FaultLoggerdSystemTest106 Failed"; 1253 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest106: end."; 1254} 1255 1256/** 1257 * @tc.name: FaultLoggerdSystemTest107 1258 * @tc.desc: test CPP crasher application: STACKOF 1259 * @tc.type: FUNC 1260 */ 1261HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest107, TestSize.Level2) 1262{ 1263 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest107: start."; 1264 string cmd = "STACKOF"; 1265 string fileName; 1266 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 1267 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1268 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1269 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1270 FAIL(); 1271 } 1272 EXPECT_TRUE(CheckCountNumStackOverFlow(fileName, pid)) << "FaultLoggerdSystemTest107 Failed"; 1273 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest107: end."; 1274} 1275 1276/** 1277 * @tc.name: FaultLoggerdSystemTest108 1278 * @tc.desc: test Cpp crasher application: StackCorruption, and check all label keywords 1279 * @tc.type: FUNC 1280 */ 1281HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest108, TestSize.Level2) 1282{ 1283 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest108: start."; 1284 string cmd = "StackCorruption"; 1285 string fileName; 1286 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 1287 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1288 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1289 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1290 FAIL(); 1291 } 1292 EXPECT_TRUE(CheckCppCrashAllLabelKeywords(fileName, pid)) << "FaultLoggerdSystemTest108 Failed"; 1293 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest108: end."; 1294} 1295 1296#if defined(PROCESSDUMP_MINIDEBUGINFO) 1297static bool CheckMinidebugSymbols(const string& filePath, const pid_t& pid, const string& option) 1298{ 1299 map<string, string> optionSymbolMap = { 1300 { string("triSIGSEGV"), string("SegmentFaultException") }, 1301 { string("triSIGARBT"), string("Abort") } 1302 }; 1303 string symbol; 1304 auto iter = optionSymbolMap.find(option); 1305 if (iter != optionSymbolMap.end()) { 1306 GTEST_LOG_(INFO) << "optionSymbolMap matched"; 1307 symbol = iter->second; 1308 } 1309 string log[] = { 1310 "Pid:" + to_string(pid), "Uid", ":crasher", "Tid:", "#00", 1311 symbol, "ParseAndDoCrash", "main", REGISTERS 1312 }; 1313 int minRegIdx = 7; // 7 : index of first REGISTERS - 1 1314 int expectNum = sizeof(log) / sizeof(log[0]); 1315 return CheckKeyWords(filePath, log, expectNum, minRegIdx) == expectNum; 1316} 1317 1318/** 1319 * @tc.name: FaultLoggerdSystemTest109 1320 * @tc.desc: trigger crasher_c SIGSEGV and check minidebug synbols 1321 * @tc.type: FUNC 1322 */ 1323HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest109, TestSize.Level2) 1324{ 1325 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest109: start."; 1326 string cmd = "triSIGSEGV"; 1327 string fileName; 1328 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 1329 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1330 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1331 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1332 FAIL(); 1333 } 1334 EXPECT_TRUE(CheckMinidebugSymbols(fileName, pid, cmd)) << "FaultLoggerdSystemTest109 Failed"; 1335 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest109: end."; 1336} 1337 1338/** 1339 * @tc.name: FaultLoggerdSystemTest110 1340 * @tc.desc: trigger crasher_cpp SIGSEGV and check minidebug synbols 1341 * @tc.type: FUNC 1342 */ 1343HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest110, TestSize.Level2) 1344{ 1345 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest110: start."; 1346 string cmd = "triSIGSEGV"; 1347 string fileName; 1348 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 1349 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1350 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1351 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1352 FAIL(); 1353 } 1354 EXPECT_TRUE(CheckMinidebugSymbols(fileName, pid, cmd)) << "FaultLoggerdSystemTest110 Failed"; 1355 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest110: end."; 1356} 1357 1358/** 1359 * @tc.name: FaultLoggerdSystemTest111 1360 * @tc.desc: trigger crasher_c SIGABRT and check minidebug synbols 1361 * @tc.type: FUNC 1362 */ 1363HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest111, TestSize.Level2) 1364{ 1365 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest111: start."; 1366 string cmd = "triSIGABRT"; 1367 string fileName; 1368 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName); 1369 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1370 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1371 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1372 FAIL(); 1373 } 1374 EXPECT_TRUE(CheckMinidebugSymbols(fileName, pid, cmd)) << "FaultLoggerdSystemTest111 Failed"; 1375 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest111: end."; 1376} 1377 1378/** 1379 * @tc.name: FaultLoggerdSystemTest112 1380 * @tc.desc: trigger crasher_cpp SIGABRT and check minidebug synbols 1381 * @tc.type: FUNC 1382 */ 1383HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest112, TestSize.Level2) 1384{ 1385 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest112: start."; 1386 string cmd = "triSIGABRT"; 1387 string fileName; 1388 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 1389 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1390 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1391 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1392 FAIL(); 1393 } 1394 EXPECT_TRUE(CheckMinidebugSymbols(fileName, pid, cmd)) << "FaultLoggerdSystemTest112 Failed"; 1395 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest112: end."; 1396} 1397#endif 1398 1399/** 1400* @tc.name: FaultLoggerdSystemTest113 1401* @tc.desc: test fetch last fatal message from libc 1402* @tc.type: FUNC 1403*/ 1404HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest113, TestSize.Level2) 1405{ 1406 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest113: start."; 1407 string cmd = "FatalMessage"; 1408 string fileName; 1409 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 1410 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1411 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1412 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1413 FAIL(); 1414 } 1415 EXPECT_TRUE(CheckCppCrashAllLabelKeywords(fileName, pid)) << "FaultLoggerdSystemTest113 Failed"; 1416 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest113: end."; 1417} 1418 1419#if defined(__aarch64__) 1420/** 1421* @tc.name: FaultLoggerdSystemTest114 1422* @tc.desc: Test async stacktrace enable in nomal thread crash case 1423* @tc.type: FUNC 1424*/ 1425HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest114, TestSize.Level2) 1426{ 1427 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest114: start."; 1428 string cmd = "AsyncStack"; 1429 string fileName; 1430 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 1431 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1432 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1433 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1434 FAIL(); 1435 } 1436 EXPECT_TRUE(CheckCppCrashAsyncStackEnableKeywords(fileName, pid)) << "FaultLoggerdSystemTest114 Failed"; 1437 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest114: end."; 1438} 1439 1440/** 1441* @tc.name: FaultLoggerdSystemTest115 1442* @tc.desc: Test async-stacktrace api enable in ffrt crash case 1443* @tc.type: FUNC 1444*/ 1445HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest115, TestSize.Level2) 1446{ 1447 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest115: start."; 1448 string cmd = "CrashInFFRT true"; 1449 string fileName; 1450 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 1451 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1452 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1453 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1454 FAIL(); 1455 } 1456 EXPECT_TRUE(CheckCppCrashAsyncStackEnableKeywords(fileName, pid)) << "FaultLoggerdSystemTest115 Failed"; 1457 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest115: end."; 1458} 1459 1460/** 1461* @tc.name: FaultLoggerdSystemTest116 1462* @tc.desc: Test async-stacktrace api enable in work callback crash case 1463* @tc.type: FUNC 1464*/ 1465HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest116, TestSize.Level2) 1466{ 1467 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest116: start."; 1468 string cmd = "CrashInLibuvWork true"; 1469 string fileName; 1470 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 1471 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1472 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1473 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1474 FAIL(); 1475 } 1476 EXPECT_TRUE(CheckCppCrashAsyncStackEnableKeywords(fileName, pid)) << "FaultLoggerdSystemTest116 Failed"; 1477 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest116: end."; 1478} 1479 1480/** 1481* @tc.name: FaultLoggerdSystemTest117 1482* @tc.desc: Test async-stacktrace api enable in timer callback crash case 1483* @tc.type: FUNC 1484*/ 1485HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest117, TestSize.Level2) 1486{ 1487 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest117: start."; 1488 string cmd = "CrashInLibuvTimer true"; 1489 string fileName; 1490 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 1491 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1492 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1493 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1494 FAIL(); 1495 } 1496 EXPECT_TRUE(CheckCppCrashAsyncStackEnableKeywords(fileName, pid)) << "FaultLoggerdSystemTest117 Failed"; 1497 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest117: end."; 1498} 1499 1500/** 1501* @tc.name: FaultLoggerdSystemTest118 1502* @tc.desc: Test async-stacktrace api enalbe in work callback done crash case 1503* @tc.type: FUNC 1504*/ 1505HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest118, TestSize.Level2) 1506{ 1507 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest118: start."; 1508 string cmd = "CrashInLibuvWorkDone true"; 1509 string fileName; 1510 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 1511 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1512 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1513 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1514 FAIL(); 1515 } 1516 EXPECT_TRUE(CheckCppCrashAsyncStackEnableKeywords(fileName, pid)) << "FaultLoggerdSystemTest118 Failed"; 1517 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest118: end."; 1518} 1519 1520/** 1521* @tc.name: FaultLoggerdSystemTest119 1522* @tc.desc: Test async-stacktrace api disable in ffrt crash case 1523* @tc.type: FUNC 1524*/ 1525HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest119, TestSize.Level2) 1526{ 1527 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest119: start."; 1528 string cmd = "CrashInFFRT false"; 1529 string fileName; 1530 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 1531 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1532 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1533 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1534 FAIL(); 1535 } 1536 EXPECT_TRUE(CheckCppCrashAsyncStackDisableKeywords(fileName, pid)) << "FaultLoggerdSystemTest119 Failed"; 1537 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest119: end."; 1538} 1539 1540/** 1541* @tc.name: FaultLoggerdSystemTest120 1542* @tc.desc: Test async-stacktrace api disable in work callback crash case 1543* @tc.type: FUNC 1544*/ 1545HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest120, TestSize.Level2) 1546{ 1547 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest120: start."; 1548 string cmd = "CrashInLibuvWork false"; 1549 string fileName; 1550 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 1551 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1552 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1553 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1554 FAIL(); 1555 } 1556 EXPECT_TRUE(CheckCppCrashAsyncStackDisableKeywords(fileName, pid)) << "FaultLoggerdSystemTest120 Failed"; 1557 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest120: end."; 1558} 1559 1560/** 1561* @tc.name: FaultLoggerdSystemTest121 1562* @tc.desc: Test async-stacktrace api disable in timer callback crash case 1563* @tc.type: FUNC 1564*/ 1565HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest121, TestSize.Level2) 1566{ 1567 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest121: start."; 1568 string cmd = "CrashInLibuvTimer false"; 1569 string fileName; 1570 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 1571 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1572 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1573 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1574 FAIL(); 1575 } 1576 EXPECT_TRUE(CheckCppCrashAsyncStackDisableKeywords(fileName, pid)) << "FaultLoggerdSystemTest121 Failed"; 1577 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest121: end."; 1578} 1579 1580/** 1581* @tc.name: FaultLoggerdSystemTest122 1582* @tc.desc: Test async-stacktrace api disable in work callback done crash case 1583* @tc.type: FUNC 1584*/ 1585HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest122, TestSize.Level2) 1586{ 1587 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest122: start."; 1588 string cmd = "CrashInLibuvWorkDone false"; 1589 string fileName; 1590 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 1591 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1592 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1593 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1594 FAIL(); 1595 } 1596 EXPECT_TRUE(CheckCppCrashAsyncStackDisableKeywords(fileName, pid)) << "FaultLoggerdSystemTest122 Failed"; 1597 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest122: end."; 1598} 1599 1600/** 1601* @tc.name: FaultLoggerdSystemTest123 1602* @tc.desc: Test crash log to /log/crash when faultloggerd unstart case 1603* @tc.type: FUNC 1604*/ 1605HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest123, TestSize.Level2) 1606{ 1607 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest123: start."; 1608 string clearCrashFilesCmd = "rm -rf /log/crash/*"; 1609 system(clearCrashFilesCmd.c_str()); 1610 1611 string stopFaultLoggerd = "service_control stop faultloggerd"; 1612 (void)ExecuteCommands(stopFaultLoggerd); 1613 1614 string cmd = "SIGABRT"; 1615 string fileName; 1616 string crashDir = "/log/crash/"; 1617 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName, 1, crashDir); 1618 1619 string startFaultLoggerd = "service_control start faultloggerd"; 1620 (void)ExecuteCommands(startFaultLoggerd); 1621 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1622 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1623 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1624 FAIL(); 1625 } 1626 EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest123 Failed"; 1627 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest123: end."; 1628} 1629 1630/** 1631* @tc.name: FaultLoggerdSystemTest124 1632* @tc.desc: Test get crash object 1633* @tc.type: FUNC 1634*/ 1635HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest124, TestSize.Level2) 1636{ 1637 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest124: start."; 1638 string cmd = "TestGetCrashObj"; 1639 string fileName; 1640 pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName); 1641 GTEST_LOG_(INFO) << "test pid(" << pid << ")" << " cppcrash file name : " << fileName; 1642 if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) { 1643 GTEST_LOG_(ERROR) << "Trigger Crash Failed."; 1644 FAIL(); 1645 } 1646 EXPECT_TRUE(CheckTestGetCrashObj(fileName, pid)) << "FaultLoggerdSystemTest124 Failed"; 1647 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest124: end."; 1648} 1649#endif 1650 1651/** 1652* @tc.name: FaultLoggerdSystemTest125 1653* @tc.desc: Test process exit after being killed 1654* @tc.type: FUNC 1655*/ 1656HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest125, TestSize.Level2) 1657{ 1658 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest125: start."; 1659 InstallTestHap("/data/FaultloggerdJsTest.hap"); 1660 string testBundleName = TEST_BUNDLE_NAME; 1661 string testAbiltyName = testBundleName + ".MainAbility"; 1662 for (int i = 0; i < 2; i++) { // 2 : check again 1663 int pid = LaunchTestHap(testAbiltyName, testBundleName); 1664 if (pid == 0) { 1665 GTEST_LOG_(ERROR) << "Failed to launch target hap."; 1666 continue; 1667 } 1668 kill(pid, SIGABRT); 1669 sleep(2); // 2 : sleep 2s 1670 int newPid = GetProcessPid(TEST_BUNDLE_NAME); 1671 EXPECT_NE(pid, newPid) << "FaultLoggerdSystemTest125 Failed"; 1672 } 1673 StopTestHap(TEST_BUNDLE_NAME); 1674 UninstallTestHap(TEST_BUNDLE_NAME); 1675 GTEST_LOG_(INFO) << "FaultLoggerdSystemTest125: end."; 1676} 1677} // namespace HiviewDFX 1678} // namespace OHOS 1679