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 
33 using namespace testing::ext;
34 using namespace std;
35 
36 #define NSPID_PATH "/data/nspid"
37 
38 namespace OHOS {
39 namespace HiviewDFX {
40 class FaultLoggerdSystemTest : public testing::Test {
41 public:
42     static void SetUpTestCase(void);
43     static void TearDownTestCase(void);
44     void SetUp();
45     void TearDown();
46 };
47 
SetUpTestCase(void)48 void 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 
TearDownTestCase(void)54 void FaultLoggerdSystemTest::TearDownTestCase(void)
55 {
56 }
57 
SetUp(void)58 void FaultLoggerdSystemTest::SetUp(void)
59 {
60 }
61 
TearDown(void)62 void FaultLoggerdSystemTest::TearDown(void)
63 {
64 }
65 
66 namespace {
67 static const int CPPCRASH_FILENAME_MIN_LENGTH = 36; // 36 : length of /data/log/faultlog/temp/cppcrash-x-x
68 static const int SIGNAL_TEST_NUM = 50;
69 }
70 
ForkAndExecuteCrasher(const string & option,const CrasherType type)71 static 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 
TriggerCrasherAndGetFileName(const string & option,const CrasherType type,string & crashFileName,int waitSec=1,const std::string & tempPath=TEMP_DIR)102 static 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 
CheckCountNum(const string & filePath,const pid_t & pid,const string & option)122 static 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 
CheckCountNumAbort(const string & filePath,const pid_t & pid)152 static 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 
CheckCountNumNullpointer(const string & filePath,const pid_t & pid)164 static 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 
CheckCountNumStackOverFlow(const string & filePath,const pid_t & pid)175 static 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 
CheckCountNumPCZero(const string & filePath,const pid_t & pid)186 static 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 
CheckCountNumOverStack(const string & filePath,const pid_t & pid)197 static 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 
CheckCountNumMultiThread(const string & filePath,const pid_t & pid)208 static 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 
GetStackTop(void)220 static 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 
WriteRealPid(int realPid)240 static void WriteRealPid(int realPid)
241 {
242     ofstream file;
243     file.open(NSPID_PATH);
244     file << std::to_string(realPid);
245     file.close();
246 }
247 
ReadRealPid(void)248 static 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 
CheckCountNumStackTop(const string & filePath,const pid_t & pid)264 static 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 
CheckCppCrashAllLabelKeywords(const string & filePath,const pid_t & pid)281 static 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__)
CheckCppCrashAsyncStackEnableKeywords(const string & filePath,const pid_t & pid)294 static 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 
CheckCppCrashAsyncStackDisableKeywords(const string & filePath,const pid_t & pid)306 static 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 
CheckTestGetCrashObj(const string & filePath,const pid_t & pid)324 static 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  */
341 HWTEST_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  */
361 HWTEST_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  */
381 HWTEST_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  */
401 HWTEST_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 */
421 HWTEST_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 */
441 HWTEST_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  */
461 HWTEST_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  */
481 HWTEST_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 */
501 HWTEST_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 */
521 HWTEST_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  */
541 HWTEST_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  */
561 HWTEST_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 */
581 HWTEST_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 */
601 HWTEST_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  */
621 HWTEST_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  */
641 HWTEST_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 */
661 HWTEST_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 */
681 HWTEST_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 */
701 HWTEST_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 */
721 HWTEST_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 */
741 HWTEST_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 */
761 HWTEST_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 */
781 HWTEST_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 */
801 HWTEST_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 */
821 HWTEST_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 */
841 HWTEST_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  */
861 HWTEST_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  */
881 HWTEST_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  */
900 HWTEST_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  */
920 HWTEST_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  */
940 HWTEST_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  */
960 HWTEST_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  */
980 HWTEST_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  */
1000 HWTEST_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  */
1020 HWTEST_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  */
1040 HWTEST_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 
1055 /**
1056  * @tc.name: FaultLoggerdSystemTest101
1057  * @tc.desc: test C crasher application: 50 Abnormal signal
1058  * @tc.type: FUNC
1059  */
1060 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest101, TestSize.Level2)
1061 {
1062     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest0009: start.";
1063     string clearTempFilesCmd = "rm -rf /data/log/faultlog/temp/*";
1064     system(clearTempFilesCmd.c_str());
1065     for (int i = 0; i < SIGNAL_TEST_NUM; i++) {
1066         system("/data/crasher_c CrashTest &");
1067     }
1068     sleep(10); // 10 : sleep for 10 seconds
1069     vector<string> files;
1070     OHOS::GetDirFiles("/data/log/faultlog/temp/", files);
1071     GTEST_LOG_(INFO) << files.size();
1072     EXPECT_EQ(files.size(), SIGNAL_TEST_NUM) << "FaultLoggerdSystemTest101 Failed";
1073 }
1074 
CrashInChildThread()1075 static void CrashInChildThread()
1076 {
1077     GTEST_LOG_(INFO) << "CrashInChildThread(): TID = " << gettid();
1078     raise(SIGSEGV);
1079 }
1080 
RunInNewPidNs(void * arg)1081 static int RunInNewPidNs(void* arg)
1082 {
1083     (void)arg;
1084     struct ProcInfo g_nsProcInfo;
1085     GetProcStatus(g_nsProcInfo);
1086     WriteRealPid(g_nsProcInfo.pid);
1087     GTEST_LOG_(INFO) << "RunInNewPidNs(): real pid = " << g_nsProcInfo.pid;
1088     GTEST_LOG_(INFO) << "RunInNewPidNs(): PID = " << getpid();
1089     GTEST_LOG_(INFO) << "RunInNewPidNs(): TID = " << gettid();
1090     thread childThread(CrashInChildThread);
1091     childThread.join();
1092     _exit(0);
1093 }
1094 
1095 /**
1096  * @tc.name: FaultLoggerdSystemTest102
1097  * @tc.desc: test crash in process with pid namespace
1098  * @tc.type: FUNC
1099  */
1100 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest102, TestSize.Level2)
1101 {
1102     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest102: start.";
1103     const int stackSz = 1024 * 1024 * 1024; // 1M
1104     void* cloneStack = mmap(nullptr, stackSz,
1105         PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, 1, 0);
1106     if (cloneStack == nullptr) {
1107         FAIL();
1108     }
1109     cloneStack = static_cast<void *>(static_cast<uint8_t *>(cloneStack) + stackSz - 1);
1110     int childPid = clone(RunInNewPidNs, cloneStack, CLONE_NEWPID | SIGCHLD, nullptr);
1111     if (childPid <= 0) {
1112         GTEST_LOG_(INFO) << "FaultLoggerdSystemTest102: Failed to clone new process. errno:" << errno;
1113         return;
1114     }
1115     // wait for log generation
1116     sleep(4); // 4 : sleep 4s
1117     int readPid = ReadRealPid();
1118     string fileName = GetCppCrashFileName(readPid);
1119     EXPECT_NE(0, fileName.size());
1120     printf("PidNs Crash File:%s\n", fileName.c_str());
1121     string log[] = {
1122         "Pid:", "Uid", "SIGSEGV", "Tid:", "#00",
1123         "Registers:", REGISTERS, "FaultStack:", "Maps:"
1124     };
1125     int minRegIdx = 5; // 5 : index of first REGISTERS - 1
1126     int expectNum = sizeof(log) / sizeof(log[0]);
1127     int count = CheckKeyWords(fileName, log, expectNum, minRegIdx);
1128     EXPECT_EQ(count, expectNum);
1129     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest102: end.";
1130 }
1131 
1132 /**
1133  * @tc.name: FaultLoggerdSystemTest103
1134  * @tc.desc: test the aging mechanism of the temp directory
1135  * @tc.type: FUNC
1136  */
1137 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest103, TestSize.Level2)
1138 {
1139     string clearTempFilesCmd = "rm -rf /data/log/faultlog/temp/*";
1140     system(clearTempFilesCmd.c_str());
1141     system("/data/crasher_c SIGSEGV"); // trigger aging mechanism
1142     sleep(1); // 1 : sleep for 1 seconds
1143     vector<string> files;
1144     OHOS::GetDirFiles("/data/log/faultlog/temp/", files);
1145     string oldcrash = "";
1146     if (!files.empty()) {
1147         oldcrash = files[0];
1148     }
1149     GTEST_LOG_(INFO) << oldcrash;
1150     files.clear();
1151     for (int i = 0; i < 25; i++) { // 25 : the count of crash file
1152         system("/data/crasher_c SIGSEGV");
1153     }
1154     for (int i = 0; i < 25; i++) { // 25 : the count of crash file
1155         sleep(3); //3 : sleep for 3 seconds
1156         system("/data/crasher_c SIGSEGV");
1157     }
1158     OHOS::GetDirFiles("/data/log/faultlog/temp/", files);
1159     for (size_t i = 0; i < files.size(); i++) {
1160         if (files[i] == oldcrash) {
1161             FAIL();
1162         }
1163     }
1164     int fileCount = files.size();
1165     GTEST_LOG_(INFO) << fileCount;
1166     system("/data/crasher_c SIGSEGV"); // trigger aging mechanism
1167     sleep(1); // 1 : sleep for 1 seconds
1168     files.clear();
1169     OHOS::GetDirFiles("/data/log/faultlog/temp/", files);
1170     EXPECT_EQ(fileCount, files.size()) << "FaultLoggerdSystemTest103 Failed";
1171 }
1172 
1173 /**
1174  * @tc.name: FaultLoggerdSystemTest0104
1175  * @tc.desc: test crash log build-id
1176  * @tc.type: FUNC
1177  */
1178 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest104, TestSize.Level2)
1179 {
1180     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest104: start.";
1181     string cmd = "SIGSEGV";
1182     string fileName;
1183     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName);
1184     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1185     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1186         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1187         FAIL();
1188     }
1189     std::ifstream file;
1190     file.open(fileName.c_str(), std::ios::in);
1191     while (!file.eof()) {
1192         string s;
1193         file >> s;
1194         if (s.find("/data/crasher_c") != string::npos) {
1195             string buildId;
1196             size_t leftBraceIdx = s.find('(');
1197             size_t rightBraceIdx = s.find(')');
1198             if (leftBraceIdx != string::npos && rightBraceIdx != string::npos) {
1199                 buildId = s.substr(leftBraceIdx + 1, rightBraceIdx - leftBraceIdx - 1);
1200                 GTEST_LOG_(INFO) << "build-id = " << buildId;
1201             }
1202             EXPECT_FALSE(buildId.empty()) << "FaultLoggerdSystemTest104 Failed";
1203             break;
1204         }
1205     }
1206     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest104: end.";
1207 }
1208 
1209 /**
1210  * @tc.name: FaultLoggerdSystemTest105
1211  * @tc.desc: test C crasher application: SIGABRT, and check all label keywords
1212  * @tc.type: FUNC
1213  */
1214 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest105, TestSize.Level2)
1215 {
1216     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest105: start.";
1217     string cmd = "SIGABRT";
1218     string fileName;
1219     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName);
1220     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1221     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1222         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1223         FAIL();
1224     }
1225     EXPECT_TRUE(CheckCppCrashAllLabelKeywords(fileName, pid)) << "FaultLoggerdSystemTest105 Failed";
1226     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest105: end.";
1227 }
1228 
1229 /**
1230  * @tc.name: FaultLoggerdSystemTest106
1231  * @tc.desc: test CPP crasher application: NullPointerDeref0
1232  * @tc.type: FUNC
1233  */
1234 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest106, TestSize.Level2)
1235 {
1236     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest106: start.";
1237     string cmd = "NullPointerDeref0";
1238     string fileName;
1239     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName);
1240     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1241     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1242         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1243         FAIL();
1244     }
1245     EXPECT_TRUE(CheckCountNumNullpointer(fileName, pid)) << "FaultLoggerdSystemTest106 Failed";
1246     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest106: end.";
1247 }
1248 
1249 /**
1250  * @tc.name: FaultLoggerdSystemTest107
1251  * @tc.desc: test CPP crasher application: STACKOF
1252  * @tc.type: FUNC
1253  */
1254 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest107, TestSize.Level2)
1255 {
1256     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest107: start.";
1257     string cmd = "STACKOF";
1258     string fileName;
1259     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName);
1260     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1261     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1262         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1263         FAIL();
1264     }
1265     EXPECT_TRUE(CheckCountNumStackOverFlow(fileName, pid)) << "FaultLoggerdSystemTest107 Failed";
1266     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest107: end.";
1267 }
1268 
1269 /**
1270  * @tc.name: FaultLoggerdSystemTest108
1271  * @tc.desc: test Cpp crasher application: StackCorruption, and check all label keywords
1272  * @tc.type: FUNC
1273  */
1274 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest108, TestSize.Level2)
1275 {
1276     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest108: start.";
1277     string cmd = "StackCorruption";
1278     string fileName;
1279     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName);
1280     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1281     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1282         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1283         FAIL();
1284     }
1285     EXPECT_TRUE(CheckCppCrashAllLabelKeywords(fileName, pid)) << "FaultLoggerdSystemTest108 Failed";
1286     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest108: end.";
1287 }
1288 
1289 #if defined(PROCESSDUMP_MINIDEBUGINFO)
CheckMinidebugSymbols(const string & filePath,const pid_t & pid,const string & option)1290 static bool CheckMinidebugSymbols(const string& filePath, const pid_t& pid, const string& option)
1291 {
1292     map<string, string> optionSymbolMap = {
1293         { string("triSIGSEGV"), string("SegmentFaultException") },
1294         { string("triSIGARBT"), string("Abort") }
1295     };
1296     string symbol;
1297     auto iter = optionSymbolMap.find(option);
1298     if (iter != optionSymbolMap.end()) {
1299         GTEST_LOG_(INFO) << "optionSymbolMap matched";
1300         symbol = iter->second;
1301     }
1302     string log[] = {
1303         "Pid:" + to_string(pid), "Uid", ":crasher", "Tid:", "#00",
1304         symbol, "ParseAndDoCrash", "main", REGISTERS
1305     };
1306     int minRegIdx = 7; // 7 : index of first REGISTERS - 1
1307     int expectNum = sizeof(log) / sizeof(log[0]);
1308     return CheckKeyWords(filePath, log, expectNum, minRegIdx) == expectNum;
1309 }
1310 
1311 /**
1312  * @tc.name: FaultLoggerdSystemTest109
1313  * @tc.desc: trigger crasher_c SIGSEGV and check minidebug synbols
1314  * @tc.type: FUNC
1315  */
1316 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest109, TestSize.Level2)
1317 {
1318     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest109: start.";
1319     string cmd = "triSIGSEGV";
1320     string fileName;
1321     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName);
1322     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1323     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1324         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1325         FAIL();
1326     }
1327     EXPECT_TRUE(CheckMinidebugSymbols(fileName, pid, cmd)) << "FaultLoggerdSystemTest109 Failed";
1328     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest109: end.";
1329 }
1330 
1331 /**
1332  * @tc.name: FaultLoggerdSystemTest110
1333  * @tc.desc: trigger crasher_cpp SIGSEGV and check minidebug synbols
1334  * @tc.type: FUNC
1335  */
1336 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest110, TestSize.Level2)
1337 {
1338     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest110: start.";
1339     string cmd = "triSIGSEGV";
1340     string fileName;
1341     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName);
1342     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1343     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1344         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1345         FAIL();
1346     }
1347     EXPECT_TRUE(CheckMinidebugSymbols(fileName, pid, cmd)) << "FaultLoggerdSystemTest110 Failed";
1348     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest110: end.";
1349 }
1350 
1351 /**
1352  * @tc.name: FaultLoggerdSystemTest111
1353  * @tc.desc: trigger crasher_c SIGABRT and check minidebug synbols
1354  * @tc.type: FUNC
1355  */
1356 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest111, TestSize.Level2)
1357 {
1358     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest111: start.";
1359     string cmd = "triSIGABRT";
1360     string fileName;
1361     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_C, fileName);
1362     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1363     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1364         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1365         FAIL();
1366     }
1367     EXPECT_TRUE(CheckMinidebugSymbols(fileName, pid, cmd)) << "FaultLoggerdSystemTest111 Failed";
1368     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest111: end.";
1369 }
1370 
1371 /**
1372  * @tc.name: FaultLoggerdSystemTest112
1373  * @tc.desc: trigger crasher_cpp SIGABRT and check minidebug synbols
1374  * @tc.type: FUNC
1375  */
1376 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest112, TestSize.Level2)
1377 {
1378     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest112: start.";
1379     string cmd = "triSIGABRT";
1380     string fileName;
1381     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName);
1382     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1383     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1384         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1385         FAIL();
1386     }
1387     EXPECT_TRUE(CheckMinidebugSymbols(fileName, pid, cmd)) << "FaultLoggerdSystemTest112 Failed";
1388     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest112: end.";
1389 }
1390 #endif
1391 
1392 /**
1393 * @tc.name: FaultLoggerdSystemTest113
1394 * @tc.desc: test fetch last fatal message from libc
1395 * @tc.type: FUNC
1396 */
1397 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest113, TestSize.Level2)
1398 {
1399     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest113: start.";
1400     string cmd = "FatalMessage";
1401     string fileName;
1402     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName);
1403     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1404     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1405         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1406         FAIL();
1407     }
1408     EXPECT_TRUE(CheckCppCrashAllLabelKeywords(fileName, pid)) << "FaultLoggerdSystemTest113 Failed";
1409     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest113: end.";
1410 }
1411 
1412 #if defined(__aarch64__)
1413 /**
1414 * @tc.name: FaultLoggerdSystemTest114
1415 * @tc.desc: Test async stacktrace enable in nomal thread crash case
1416 * @tc.type: FUNC
1417 */
1418 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest114, TestSize.Level2)
1419 {
1420     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest114: start.";
1421     string cmd = "AsyncStack";
1422     string fileName;
1423     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName);
1424     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1425     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1426         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1427         FAIL();
1428     }
1429     EXPECT_TRUE(CheckCppCrashAsyncStackEnableKeywords(fileName, pid)) << "FaultLoggerdSystemTest114 Failed";
1430     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest114: end.";
1431 }
1432 
1433 /**
1434 * @tc.name: FaultLoggerdSystemTest115
1435 * @tc.desc: Test async-stacktrace api enable in ffrt crash case
1436 * @tc.type: FUNC
1437 */
1438 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest115, TestSize.Level2)
1439 {
1440     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest115: start.";
1441     string cmd = "CrashInFFRT true";
1442     string fileName;
1443     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName);
1444     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1445     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1446         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1447         FAIL();
1448     }
1449     EXPECT_TRUE(CheckCppCrashAsyncStackEnableKeywords(fileName, pid)) << "FaultLoggerdSystemTest115 Failed";
1450     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest115: end.";
1451 }
1452 
1453 /**
1454 * @tc.name: FaultLoggerdSystemTest116
1455 * @tc.desc: Test async-stacktrace api enable in work callback crash case
1456 * @tc.type: FUNC
1457 */
1458 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest116, TestSize.Level2)
1459 {
1460     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest116: start.";
1461     string cmd = "CrashInLibuvWork true";
1462     string fileName;
1463     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName);
1464     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1465     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1466         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1467         FAIL();
1468     }
1469     EXPECT_TRUE(CheckCppCrashAsyncStackEnableKeywords(fileName, pid)) << "FaultLoggerdSystemTest116 Failed";
1470     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest116: end.";
1471 }
1472 
1473 /**
1474 * @tc.name: FaultLoggerdSystemTest117
1475 * @tc.desc: Test async-stacktrace api enable in timer callback crash case
1476 * @tc.type: FUNC
1477 */
1478 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest117, TestSize.Level2)
1479 {
1480     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest117: start.";
1481     string cmd = "CrashInLibuvTimer true";
1482     string fileName;
1483     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName);
1484     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1485     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1486         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1487         FAIL();
1488     }
1489     EXPECT_TRUE(CheckCppCrashAsyncStackEnableKeywords(fileName, pid)) << "FaultLoggerdSystemTest117 Failed";
1490     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest117: end.";
1491 }
1492 
1493 /**
1494 * @tc.name: FaultLoggerdSystemTest118
1495 * @tc.desc: Test async-stacktrace api enalbe in work callback done crash case
1496 * @tc.type: FUNC
1497 */
1498 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest118, TestSize.Level2)
1499 {
1500     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest118: start.";
1501     string cmd = "CrashInLibuvWorkDone true";
1502     string fileName;
1503     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName);
1504     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1505     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1506         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1507         FAIL();
1508     }
1509     EXPECT_TRUE(CheckCppCrashAsyncStackEnableKeywords(fileName, pid)) << "FaultLoggerdSystemTest118 Failed";
1510     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest118: end.";
1511 }
1512 
1513 /**
1514 * @tc.name: FaultLoggerdSystemTest119
1515 * @tc.desc: Test async-stacktrace api disable in ffrt crash case
1516 * @tc.type: FUNC
1517 */
1518 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest119, TestSize.Level2)
1519 {
1520     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest119: start.";
1521     string cmd = "CrashInFFRT false";
1522     string fileName;
1523     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName);
1524     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1525     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1526         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1527         FAIL();
1528     }
1529     EXPECT_TRUE(CheckCppCrashAsyncStackDisableKeywords(fileName, pid)) << "FaultLoggerdSystemTest119 Failed";
1530     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest119: end.";
1531 }
1532 
1533 /**
1534 * @tc.name: FaultLoggerdSystemTest120
1535 * @tc.desc: Test async-stacktrace api disable in work callback crash case
1536 * @tc.type: FUNC
1537 */
1538 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest120, TestSize.Level2)
1539 {
1540     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest120: start.";
1541     string cmd = "CrashInLibuvWork false";
1542     string fileName;
1543     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName);
1544     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1545     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1546         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1547         FAIL();
1548     }
1549     EXPECT_TRUE(CheckCppCrashAsyncStackDisableKeywords(fileName, pid)) << "FaultLoggerdSystemTest120 Failed";
1550     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest120: end.";
1551 }
1552 
1553 /**
1554 * @tc.name: FaultLoggerdSystemTest121
1555 * @tc.desc: Test async-stacktrace api disable in timer callback crash case
1556 * @tc.type: FUNC
1557 */
1558 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest121, TestSize.Level2)
1559 {
1560     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest121: start.";
1561     string cmd = "CrashInLibuvTimer false";
1562     string fileName;
1563     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName);
1564     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1565     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1566         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1567         FAIL();
1568     }
1569     EXPECT_TRUE(CheckCppCrashAsyncStackDisableKeywords(fileName, pid)) << "FaultLoggerdSystemTest121 Failed";
1570     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest121: end.";
1571 }
1572 
1573 /**
1574 * @tc.name: FaultLoggerdSystemTest122
1575 * @tc.desc: Test async-stacktrace api disable in work callback done crash case
1576 * @tc.type: FUNC
1577 */
1578 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest122, TestSize.Level2)
1579 {
1580     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest122: start.";
1581     string cmd = "CrashInLibuvWorkDone false";
1582     string fileName;
1583     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName);
1584     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1585     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1586         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1587         FAIL();
1588     }
1589     EXPECT_TRUE(CheckCppCrashAsyncStackDisableKeywords(fileName, pid)) << "FaultLoggerdSystemTest122 Failed";
1590     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest122: end.";
1591 }
1592 
1593 /**
1594 * @tc.name: FaultLoggerdSystemTest123
1595 * @tc.desc: Test crash log to /log/crash when faultloggerd unstart case
1596 * @tc.type: FUNC
1597 */
1598 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest123, TestSize.Level2)
1599 {
1600     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest123: start.";
1601     string clearCrashFilesCmd = "rm -rf /log/crash/*";
1602     system(clearCrashFilesCmd.c_str());
1603 
1604     string stopFaultLoggerd = "service_control stop faultloggerd";
1605     (void)ExecuteCommands(stopFaultLoggerd);
1606 
1607     string cmd = "SIGABRT";
1608     string fileName;
1609     string crashDir = "/log/crash/";
1610     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName, 1, crashDir);
1611 
1612     string startFaultLoggerd = "service_control start faultloggerd";
1613     (void)ExecuteCommands(startFaultLoggerd);
1614     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1615     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1616         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1617         FAIL();
1618     }
1619     EXPECT_TRUE(CheckCountNum(fileName, pid, cmd)) << "FaultLoggerdSystemTest123 Failed";
1620     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest123: end.";
1621 }
1622 
1623 /**
1624 * @tc.name: FaultLoggerdSystemTest124
1625 * @tc.desc: Test get crash object
1626 * @tc.type: FUNC
1627 */
1628 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest124, TestSize.Level2)
1629 {
1630     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest124: start.";
1631     string cmd = "TestGetCrashObj";
1632     string fileName;
1633     pid_t pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName);
1634     GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1635     if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1636         GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1637         FAIL();
1638     }
1639     EXPECT_TRUE(CheckTestGetCrashObj(fileName, pid)) << "FaultLoggerdSystemTest124 Failed";
1640     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest124: end.";
1641 }
1642 #endif
1643 
1644 /**
1645 * @tc.name: FaultLoggerdSystemTest125
1646 * @tc.desc: Test process exit after being killed
1647 * @tc.type: FUNC
1648 */
1649 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest125, TestSize.Level2)
1650 {
1651     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest125: start.";
1652     InstallTestHap("/data/FaultloggerdJsTest.hap");
1653     string testBundleName = TEST_BUNDLE_NAME;
1654     string testAbiltyName = testBundleName + ".MainAbility";
1655     for (int i = 0; i < 2; i++) { // 2 : check again
1656         int pid = LaunchTestHap(testAbiltyName, testBundleName);
1657         if (pid == 0) {
1658             GTEST_LOG_(ERROR) << "Failed to launch target hap.";
1659             continue;
1660         }
1661         kill(pid, SIGABRT);
1662         sleep(2); // 2 : sleep 2s
1663         int newPid = GetProcessPid(TEST_BUNDLE_NAME);
1664         EXPECT_NE(pid, newPid) << "FaultLoggerdSystemTest125 Failed";
1665     }
1666     StopTestHap(TEST_BUNDLE_NAME);
1667     UninstallTestHap(TEST_BUNDLE_NAME);
1668     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest125: end.";
1669 }
1670 
1671 #if defined(__aarch64__)
1672 /**
1673 * @tc.name: FaultLoggerdSystemTest126
1674 * @tc.desc: Test /log/crash files max num when faultloggerd unstart case
1675 * @tc.type: FUNC
1676 */
1677 HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest126, TestSize.Level2)
1678 {
1679     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest126: start.";
1680     string clearCrashFilesCmd = "rm -rf /log/crash/*";
1681     system(clearCrashFilesCmd.c_str());
1682 
1683     string stopFaultLoggerd = "service_control stop faultloggerd";
1684     string startFaultLoggerd = "service_control start faultloggerd";
1685     (void)ExecuteCommands(stopFaultLoggerd);
1686 
1687     string cmd = "SIGABRT";
1688     string fileName;
1689     string crashDir = "/log/crash/";
1690     pid_t pid = -1;
1691     int maxFilesNum = 5;
1692 
1693     for (int i = 0; i < (maxFilesNum + 1); ++i) {
1694         pid = TriggerCrasherAndGetFileName(cmd, CRASHER_CPP, fileName, 1, crashDir);
1695         GTEST_LOG_(INFO) << "test pid(" << pid << ")"  << " cppcrash file name : " << fileName;
1696         if (pid < 0 || fileName.size() < CPPCRASH_FILENAME_MIN_LENGTH) {
1697             GTEST_LOG_(ERROR) << "Trigger Crash Failed.";
1698             (void)ExecuteCommands(startFaultLoggerd);
1699             FAIL();
1700         }
1701     }
1702     (void)ExecuteCommands(startFaultLoggerd);
1703     std::vector<std::string> files;
1704     ReadDirFiles(crashDir, files);
1705     EXPECT_TRUE(files.size() <= maxFilesNum) << "FaultLoggerdSystemTest126 Failed";
1706     GTEST_LOG_(INFO) << "FaultLoggerdSystemTest126: end.";
1707 }
1708 #endif
1709 } // namespace HiviewDFX
1710 } // namespace OHOS
1711