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