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