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