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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest001, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest002, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest003, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest004, TestSize.Level2)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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest005, TestSize.Level2)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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest006, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest007, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest008, TestSize.Level2)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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest009, TestSize.Level2)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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest010, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest011, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest012, TestSize.Level2)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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest013, TestSize.Level2)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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest014, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest015, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest016, TestSize.Level2)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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest017, TestSize.Level2)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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest018, TestSize.Level2)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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest019, TestSize.Level2)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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest020, TestSize.Level2)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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest021, TestSize.Level2)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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest022, TestSize.Level2)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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest023, TestSize.Level2)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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest024, TestSize.Level2)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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest025, TestSize.Level2)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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest026, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest027, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest028, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest029, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest030, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest031, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest032, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest033, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest034, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest035, TestSize.Level2)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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest036, TestSize.Level2)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 
GenerateCrashLogFiles()1055 void 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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest101, TestSize.Level2)1068 HWTEST_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 
CrashInChildThread()1080 static void CrashInChildThread()
1081 {
1082     GTEST_LOG_(INFO) << "CrashInChildThread(): TID = " << gettid();
1083     raise(SIGSEGV);
1084 }
1085 
RunInNewPidNs(void* arg)1086 static 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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest102, TestSize.Level2)1105 HWTEST_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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest103, TestSize.Level2)1144 HWTEST_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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest104, TestSize.Level2)1185 HWTEST_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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest105, TestSize.Level2)1221 HWTEST_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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest106, TestSize.Level2)1241 HWTEST_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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest107, TestSize.Level2)1261 HWTEST_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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest108, TestSize.Level2)1281 HWTEST_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)
CheckMinidebugSymbols(const string& filePath, const pid_t& pid, const string& option)1297 static 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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest109, TestSize.Level2)1323 HWTEST_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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest110, TestSize.Level2)1343 HWTEST_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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest111, TestSize.Level2)1363 HWTEST_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  */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest112, TestSize.Level2)1383 HWTEST_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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest113, TestSize.Level2)1404 HWTEST_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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest114, TestSize.Level2)1425 HWTEST_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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest115, TestSize.Level2)1445 HWTEST_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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest116, TestSize.Level2)1465 HWTEST_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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest117, TestSize.Level2)1485 HWTEST_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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest118, TestSize.Level2)1505 HWTEST_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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest119, TestSize.Level2)1525 HWTEST_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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest120, TestSize.Level2)1545 HWTEST_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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest121, TestSize.Level2)1565 HWTEST_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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest122, TestSize.Level2)1585 HWTEST_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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest123, TestSize.Level2)1605 HWTEST_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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest124, TestSize.Level2)1635 HWTEST_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 */
HWTEST_F(FaultLoggerdSystemTest, FaultLoggerdSystemTest125, TestSize.Level2)1656 HWTEST_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