1 /*
2 * Copyright (c) 2021 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 /* This files contains process dump module unittest. */
17
18 #include "process_dump_test.h"
19
20 #include <memory>
21 #include <string>
22
23 #include "dfx_regs.h"
24 #include "dfx_dump_request.h"
25 #include "dfx_signal.h"
26 #include "dfx_thread.h"
27 #include "process_dumper.h"
28 #include "dfx_unwind_remote.h"
29 #include "dfx_util.h"
30
31 using namespace OHOS::HiviewDFX;
32 using namespace testing::ext;
33 using namespace std;
34
35 static const int CMD_BUF_LEN = 100;
36
SetUpTestCase(void)37 void ProcessDumpTest::SetUpTestCase(void)
38 {
39 }
40
TearDownTestCase(void)41 void ProcessDumpTest::TearDownTestCase(void)
42 {
43 }
44
SetUp(void)45 void ProcessDumpTest::SetUp(void)
46 {
47 }
48
TearDown(void)49 void ProcessDumpTest::TearDown(void)
50 {
51 }
52
GetProcessPid(std::string processName)53 int ProcessDumpTest::GetProcessPid(std::string processName)
54 {
55 std::string procCMD = "pgrep '" + processName + "'";
56 GTEST_LOG_(INFO) << "threadCMD = " << procCMD;
57 FILE *procFileInfo = nullptr;
58 procFileInfo = popen(procCMD.c_str(), "r");
59 if (procFileInfo == nullptr) {
60 perror("popen execute failed");
61 exit(1);
62 }
63 std::string processPid;
64 char resultBuf[CMD_BUF_LEN] = { 0, };
65 while (fgets(resultBuf, sizeof(resultBuf), procFileInfo) != nullptr) {
66 processPid = resultBuf;
67 GTEST_LOG_(INFO) << "applyPid: " << processPid;
68 }
69 pclose(procFileInfo);
70 return std::atoi(processPid.c_str());
71 }
72
73 namespace {
74 constexpr int TEST_PID = 243;
75 /**
76 * @tc.name: ProcessDumpTest001
77 * @tc.desc: test get dump type
78 * @tc.type: FUNC
79 */
80 HWTEST_F (ProcessDumpTest, ProcessDumpTest001, TestSize.Level2)
81 {
82 GTEST_LOG_(INFO) << "ProcessDumpTest001: start.";
83 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
84 int32_t inputType = 1;
85 if (processDump != nullptr) {
86 processDump->SetType(static_cast<ProcessDumpType>(inputType));
87 }
88 ProcessDumpType outputType = processDump->GetType();
89 EXPECT_EQ(true, inputType == outputType) << "ProcessDumpTest001 Failed";
90 GTEST_LOG_(INFO) << "ProcessDumpTest001: end.";
91 }
92
93 /**
94 * @tc.name: ProcessDumpTest002
95 * @tc.desc: test get dump type
96 * @tc.type: FUNC
97 */
98 HWTEST_F (ProcessDumpTest, ProcessDumpTest002, TestSize.Level2)
99 {
100 GTEST_LOG_(INFO) << "ProcessDumpTest002: start.";
101 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
102 int32_t inputType = 164;
103 if (processDump != nullptr) {
104 processDump->SetType(static_cast<ProcessDumpType>(inputType));
105 }
106 ProcessDumpType outputType = processDump->GetType();
107 EXPECT_EQ(true, inputType == outputType) << "ProcessDumpTest002 Failed";
108 GTEST_LOG_(INFO) << "ProcessDumpTest002: end.";
109 }
110
111 /**
112 * @tc.name: ProcessDumpTest003
113 * @tc.desc: test get dump type
114 * @tc.type: FUNC
115 */
116 HWTEST_F (ProcessDumpTest, ProcessDumpTest003, TestSize.Level2)
117 {
118 GTEST_LOG_(INFO) << "ProcessDumpTest003: start.";
119 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
120 int32_t inputType = 3;
121 if (processDump != nullptr) {
122 processDump->SetType(static_cast<ProcessDumpType>(inputType));
123 }
124 ProcessDumpType outputType = processDump->GetType();
125 EXPECT_EQ(true, inputType == outputType) << "ProcessDumpTest003 Failed";
126 GTEST_LOG_(INFO) << "ProcessDumpTest003: end.";
127 }
128
129 /**
130 * @tc.name: ProcessDumpTest004
131 * @tc.desc: test get dump tid
132 * @tc.type: FUNC
133 */
134 HWTEST_F (ProcessDumpTest, ProcessDumpTest004, TestSize.Level2)
135 {
136 GTEST_LOG_(INFO) << "ProcessDumpTest004: start.";
137 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
138 int32_t inputTid = 1;
139 if (processDump != nullptr) {
140 processDump->SetTid(inputTid);
141 }
142 int32_t outputTid = processDump->GetTid();
143 EXPECT_EQ(true, inputTid == outputTid) << "ProcessDumpTest004 Failed";
144 GTEST_LOG_(INFO) << "ProcessDumpTest004: end.";
145 }
146
147 /**
148 * @tc.name: ProcessDumpTest005
149 * @tc.desc: test get dump tid
150 * @tc.type: FUNC
151 */
152 HWTEST_F (ProcessDumpTest, ProcessDumpTest005, TestSize.Level2)
153 {
154 GTEST_LOG_(INFO) << "ProcessDumpTest005: start.";
155 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
156 int32_t inputTid = 164;
157 if (processDump != nullptr) {
158 processDump->SetTid(inputTid);
159 }
160 int32_t outputTid = processDump->GetTid();
161 EXPECT_EQ(true, inputTid == outputTid) << "ProcessDumpTest005 Failed";
162 GTEST_LOG_(INFO) << "ProcessDumpTest005: end.";
163 }
164
165 /**
166 * @tc.name: ProcessDumpTest006
167 * @tc.desc: test get dump tid
168 * @tc.type: FUNC
169 */
170 HWTEST_F (ProcessDumpTest, ProcessDumpTest006, TestSize.Level2)
171 {
172 GTEST_LOG_(INFO) << "ProcessDumpTest006: start.";
173 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
174 int32_t inputTid = 3;
175 if (processDump != nullptr) {
176 processDump->SetTid(inputTid);
177 }
178 int32_t outputTid = processDump->GetTid();
179 EXPECT_EQ(true, inputTid == outputTid) << "ProcessDumpTest006 Failed";
180 GTEST_LOG_(INFO) << "ProcessDumpTest006: end.";
181 }
182
183 /**
184 * @tc.name: ProcessDumpTest007
185 * @tc.desc: test get dump pid
186 * @tc.type: FUNC
187 */
188 HWTEST_F (ProcessDumpTest, ProcessDumpTest007, TestSize.Level2)
189 {
190 GTEST_LOG_(INFO) << "ProcessDumpTest007: start.";
191 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
192 int32_t inputPid = 1;
193 if (processDump != nullptr) {
194 processDump->SetPid(inputPid);
195 }
196 int32_t outputPid = processDump->GetPid();
197 EXPECT_EQ(true, inputPid == outputPid) << "ProcessDumpTest007 Failed";
198 GTEST_LOG_(INFO) << "ProcessDumpTest007: end.";
199 }
200
201 /**
202 * @tc.name: ProcessDumpTest008
203 * @tc.desc: test get dump pid
204 * @tc.type: FUNC
205 */
206 HWTEST_F (ProcessDumpTest, ProcessDumpTest008, TestSize.Level2)
207 {
208 GTEST_LOG_(INFO) << "ProcessDumpTest008: start.";
209 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
210 int32_t inputPid = 164;
211 if (processDump != nullptr) {
212 processDump->SetPid(inputPid);
213 }
214 int32_t outputPid = processDump->GetPid();
215 EXPECT_EQ(true, inputPid == outputPid) << "ProcessDumpTest008 Failed";
216 GTEST_LOG_(INFO) << "ProcessDumpTest008: end.";
217 }
218
219 /**
220 * @tc.name: ProcessDumpTest009
221 * @tc.desc: test get dump pid
222 * @tc.type: FUNC
223 */
224 HWTEST_F (ProcessDumpTest, ProcessDumpTest009, TestSize.Level2)
225 {
226 GTEST_LOG_(INFO) << "ProcessDumpTest009: start.";
227 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
228 int32_t inputPid = 3;
229 if (processDump != nullptr) {
230 processDump->SetPid(inputPid);
231 }
232 int32_t outputPid = processDump->GetPid();
233 EXPECT_EQ(true, inputPid == outputPid) << "ProcessDumpTest009 Failed";
234 GTEST_LOG_(INFO) << "ProcessDumpTest009: end.";
235 }
236
237 /**
238 * @tc.name: ProcessDumpTest010
239 * @tc.desc: test get dump uid
240 * @tc.type: FUNC
241 */
242 HWTEST_F (ProcessDumpTest, ProcessDumpTest010, TestSize.Level2)
243 {
244 GTEST_LOG_(INFO) << "ProcessDumpTest010: start.";
245 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
246 uint32_t inputUid = 1;
247 if (processDump != nullptr) {
248 processDump->SetUid(inputUid);
249 }
250 uint32_t outputUid = processDump->GetUid();
251 EXPECT_EQ(true, inputUid == outputUid) << "ProcessDumpTest010 Failed";
252 GTEST_LOG_(INFO) << "ProcessDumpTest010: end.";
253 }
254
255 /**
256 * @tc.name: ProcessDumpTest011
257 * @tc.desc: test get dump uid
258 * @tc.type: FUNC
259 */
260 HWTEST_F (ProcessDumpTest, ProcessDumpTest011, TestSize.Level2)
261 {
262 GTEST_LOG_(INFO) << "ProcessDumpTest011: start.";
263 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
264 uint32_t inputUid = 164;
265 if (processDump != nullptr) {
266 processDump->SetUid(inputUid);
267 }
268 uint32_t outputUid = processDump->GetUid();
269 EXPECT_EQ(true, inputUid == outputUid) << "ProcessDumpTest011 Failed";
270 GTEST_LOG_(INFO) << "ProcessDumpTest011: end.";
271 }
272
273 /**
274 * @tc.name: ProcessDumpTest012
275 * @tc.desc: test get dump uid
276 * @tc.type: FUNC
277 */
278 HWTEST_F (ProcessDumpTest, ProcessDumpTest012, TestSize.Level2)
279 {
280 GTEST_LOG_(INFO) << "ProcessDumpTest012: start.";
281 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
282 uint32_t inputUid = 3;
283 if (processDump != nullptr) {
284 processDump->SetUid(inputUid);
285 }
286 uint32_t outputUid = processDump->GetUid();
287 EXPECT_EQ(true, inputUid == outputUid) << "ProcessDumpTest012 Failed";
288 GTEST_LOG_(INFO) << "ProcessDumpTest012: end.";
289 }
290
291 /**
292 * @tc.name: ProcessDumpTest013
293 * @tc.desc: test get dump reserved
294 * @tc.type: FUNC
295 */
296 HWTEST_F (ProcessDumpTest, ProcessDumpTest013, TestSize.Level2)
297 {
298 GTEST_LOG_(INFO) << "ProcessDumpTest013: start.";
299 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
300 int32_t inputReserved = 1;
301 if (processDump != nullptr) {
302 processDump->SetReserved(inputReserved);
303 }
304 int32_t outputReserved = processDump->GetReserved();
305 EXPECT_EQ(true, inputReserved == outputReserved) << "ProcessDumpTest013 Failed";
306 GTEST_LOG_(INFO) << "ProcessDumpTest013: end.";
307 }
308
309 /**
310 * @tc.name: ProcessDumpTest014
311 * @tc.desc: test get dump reserved
312 * @tc.type: FUNC
313 */
314 HWTEST_F (ProcessDumpTest, ProcessDumpTest014, TestSize.Level2)
315 {
316 GTEST_LOG_(INFO) << "ProcessDumpTest014: start.";
317 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
318 int32_t inputReserved = 164;
319 if (processDump != nullptr) {
320 processDump->SetReserved(inputReserved);
321 }
322 int32_t outputReserved = processDump->GetReserved();
323 EXPECT_EQ(true, inputReserved == outputReserved) << "ProcessDumpTest014 Failed";
324 GTEST_LOG_(INFO) << "ProcessDumpTest014: end.";
325 }
326
327 /**
328 * @tc.name: ProcessDumpTest015
329 * @tc.desc: test get dump reserved
330 * @tc.type: FUNC
331 */
332 HWTEST_F (ProcessDumpTest, ProcessDumpTest015, TestSize.Level2)
333 {
334 GTEST_LOG_(INFO) << "ProcessDumpTest015: start.";
335 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
336 int32_t inputReserved = 3;
337 if (processDump != nullptr) {
338 processDump->SetReserved(inputReserved);
339 }
340 int32_t outputReserved = processDump->GetReserved();
341 EXPECT_EQ(true, inputReserved == outputReserved) << "ProcessDumpTest015 Failed";
342 GTEST_LOG_(INFO) << "ProcessDumpTest015: end.";
343 }
344
345 /**
346 * @tc.name: ProcessDumpTest016
347 * @tc.desc: test get dump timeStamp
348 * @tc.type: FUNC
349 */
350 HWTEST_F (ProcessDumpTest, ProcessDumpTest016, TestSize.Level2)
351 {
352 GTEST_LOG_(INFO) << "ProcessDumpTest016: start.";
353 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
354 uint64_t inputTimeStamp= 1;
355 if (processDump != nullptr) {
356 processDump->SetTimeStamp(inputTimeStamp);
357 }
358 uint64_t outputTimeStamp = processDump->GetTimeStamp();
359 EXPECT_EQ(true, inputTimeStamp == outputTimeStamp) << "ProcessDumpTest016 Failed";
360 GTEST_LOG_(INFO) << "ProcessDumpTest016: end.";
361 }
362
363 /**
364 * @tc.name: ProcessDumpTest017
365 * @tc.desc: test get dump timeStamp
366 * @tc.type: FUNC
367 */
368 HWTEST_F (ProcessDumpTest, ProcessDumpTest017, TestSize.Level2)
369 {
370 GTEST_LOG_(INFO) << "ProcessDumpTest017: start.";
371 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
372 uint64_t inputTimeStamp = 164;
373 if (processDump != nullptr) {
374 processDump->SetTimeStamp(inputTimeStamp);
375 }
376 uint64_t outputTimeStamp = processDump->GetTimeStamp();
377 EXPECT_EQ(true, inputTimeStamp == outputTimeStamp) << "ProcessDumpTest017 Failed";
378 GTEST_LOG_(INFO) << "ProcessDumpTest017: end.";
379 }
380
381 /**
382 * @tc.name: ProcessDumpTest018
383 * @tc.desc: test get dump timeStamp
384 * @tc.type: FUNC
385 */
386 HWTEST_F (ProcessDumpTest, ProcessDumpTest018, TestSize.Level2)
387 {
388 GTEST_LOG_(INFO) << "ProcessDumpTest018: start.";
389 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
390 uint64_t inputTimeStamp= 3;
391 if (processDump != nullptr) {
392 processDump->SetTimeStamp(inputTimeStamp);
393 }
394 uint64_t outputTimeStamp = processDump->GetTimeStamp();
395 EXPECT_EQ(true, inputTimeStamp == outputTimeStamp) << "ProcessDumpTest018 Failed";
396 GTEST_LOG_(INFO) << "ProcessDumpTest018: end.";
397 }
398
399 /**
400 * @tc.name: ProcessDumpTest019
401 * @tc.desc: test get dump timeStamp
402 * @tc.type: FUNC
403 */
404 HWTEST_F (ProcessDumpTest, ProcessDumpTest019, TestSize.Level2)
405 {
406 GTEST_LOG_(INFO) << "ProcessDumpTest019: start.";
407 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
408 uint64_t inputTimeStamp= 4;
409 if (processDump != nullptr) {
410 processDump->SetTimeStamp(inputTimeStamp);
411 }
412 uint64_t outputTimeStamp = processDump->GetTimeStamp();
413 EXPECT_EQ(true, inputTimeStamp == outputTimeStamp) << "ProcessDumpTest019 Failed";
414 GTEST_LOG_(INFO) << "ProcessDumpTest019: end.";
415 }
416
417 /**
418 * @tc.name: ProcessDumpTest020
419 * @tc.desc: test get dump timeStamp
420 * @tc.type: FUNC
421 */
422 HWTEST_F (ProcessDumpTest, ProcessDumpTest020, TestSize.Level2)
423 {
424 GTEST_LOG_(INFO) << "ProcessDumpTest020: start.";
425 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
426 uint64_t inputTimeStamp= 5;
427 if (processDump != nullptr) {
428 processDump->SetTimeStamp(inputTimeStamp);
429 }
430 uint64_t outputTimeStamp = processDump->GetTimeStamp();
431 EXPECT_EQ(true, inputTimeStamp == outputTimeStamp) << "ProcessDumpTest020 Failed";
432 GTEST_LOG_(INFO) << "ProcessDumpTest020: end.";
433 }
434
435 /**
436 * @tc.name: ProcessDumpTest021
437 * @tc.desc: test get dump sigInfo
438 * @tc.type: FUNC
439 */
440 HWTEST_F (ProcessDumpTest, ProcessDumpTest021, TestSize.Level2)
441 {
442 GTEST_LOG_(INFO) << "ProcessDumpTest021: start.";
443 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
444 siginfo_t inputSigInfo;
445 inputSigInfo.si_pid = 1;
446 if (processDump != nullptr) {
447 processDump->SetSiginfo(inputSigInfo);
448 }
449 siginfo_t outputSigInfo = processDump->GetSiginfo();
450 EXPECT_EQ(true, outputSigInfo.si_pid == inputSigInfo.si_pid) << "ProcessDumpTest021 Failed";
451 GTEST_LOG_(INFO) << "ProcessDumpTest021: end.";
452 }
453
454 /**
455 * @tc.name: ProcessDumpTest022
456 * @tc.desc: test get dump sigInfo
457 * @tc.type: FUNC
458 */
459 HWTEST_F (ProcessDumpTest, ProcessDumpTest022, TestSize.Level2)
460 {
461 GTEST_LOG_(INFO) << "ProcessDumpTest022: start.";
462 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
463 siginfo_t inputSigInfo;
464 inputSigInfo.si_pid = 1;
465 if (processDump != nullptr) {
466 processDump->SetSiginfo(inputSigInfo);
467 }
468 siginfo_t outputSigInfo = processDump->GetSiginfo();
469 EXPECT_EQ(true, outputSigInfo.si_pid == inputSigInfo.si_pid) << "ProcessDumpTest022 Failed";
470 GTEST_LOG_(INFO) << "ProcessDumpTest022: end.";
471 }
472
473 /**
474 * @tc.name: ProcessDumpTest023
475 * @tc.desc: test get dump sigInfo
476 * @tc.type: FUNC
477 */
478 HWTEST_F (ProcessDumpTest, ProcessDumpTest023, TestSize.Level2)
479 {
480 GTEST_LOG_(INFO) << "ProcessDumpTest023: start.";
481 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
482 siginfo_t inputSigInfo;
483 inputSigInfo.si_pid = 1;
484 if (processDump != nullptr) {
485 processDump->SetSiginfo(inputSigInfo);
486 }
487 siginfo_t outputSigInfo = processDump->GetSiginfo();
488 EXPECT_EQ(true, outputSigInfo.si_pid == inputSigInfo.si_pid) << "ProcessDumpTest023 Failed";
489 GTEST_LOG_(INFO) << "ProcessDumpTest023: end.";
490 }
491
492 /**
493 * @tc.name: ProcessDumpTest024
494 * @tc.desc: test get dump sigInfo
495 * @tc.type: FUNC
496 */
497 HWTEST_F (ProcessDumpTest, ProcessDumpTest024, TestSize.Level2)
498 {
499 GTEST_LOG_(INFO) << "ProcessDumpTest024: start.";
500 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
501 siginfo_t inputSigInfo;
502 inputSigInfo.si_pid = 1;
503 if (processDump != nullptr) {
504 processDump->SetSiginfo(inputSigInfo);
505 }
506 siginfo_t outputSigInfo = processDump->GetSiginfo();
507 EXPECT_EQ(true, outputSigInfo.si_pid == inputSigInfo.si_pid) << "ProcessDumpTest024 Failed";
508 GTEST_LOG_(INFO) << "ProcessDumpTest024: end.";
509 }
510
511 /**
512 * @tc.name: ProcessDumpTest025
513 * @tc.desc: test get dump sigInfo
514 * @tc.type: FUNC
515 */
516 HWTEST_F (ProcessDumpTest, ProcessDumpTest025, TestSize.Level2)
517 {
518 GTEST_LOG_(INFO) << "ProcessDumpTest025: start.";
519 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
520 siginfo_t inputSigInfo;
521 inputSigInfo.si_pid = 1;
522 if (processDump != nullptr) {
523 processDump->SetSiginfo(inputSigInfo);
524 }
525 siginfo_t outputSigInfo = processDump->GetSiginfo();
526 EXPECT_EQ(true, outputSigInfo.si_pid == inputSigInfo.si_pid) << "ProcessDumpTest025 Failed";
527 GTEST_LOG_(INFO) << "ProcessDumpTest025: end.";
528 }
529
530 /**
531 * @tc.name: ProcessDumpTest026
532 * @tc.desc: test get dump context
533 * @tc.type: FUNC
534 */
535 HWTEST_F (ProcessDumpTest, ProcessDumpTest026, TestSize.Level2)
536 {
537 GTEST_LOG_(INFO) << "ProcessDumpTest026: start.";
538 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
539 ucontext_t inputContext;
540 inputContext.uc_flags = 1.0;
541 if (processDump != nullptr) {
542 processDump->SetContext(inputContext);
543 }
544 ucontext_t outputContext = processDump->GetContext();
545 EXPECT_EQ(true, outputContext.uc_flags == inputContext.uc_flags) << "GetContext Failed";
546 GTEST_LOG_(INFO) << "ProcessDumpTest026: end.";
547 }
548
549 /**
550 * @tc.name: ProcessDumpTest027
551 * @tc.desc: test get dump context
552 * @tc.type: FUNC
553 */
554 HWTEST_F (ProcessDumpTest, ProcessDumpTest027, TestSize.Level2)
555 {
556 GTEST_LOG_(INFO) << "ProcessDumpTest027: start.";
557 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
558 ucontext_t inputContext;
559 inputContext.uc_flags = 164.0;
560 if (processDump != nullptr) {
561 processDump->SetContext(inputContext);
562 }
563 ucontext_t outputContext = processDump->GetContext();
564 EXPECT_EQ(true, outputContext.uc_flags == inputContext.uc_flags) << "ProcessDumpTest027 Failed";
565 GTEST_LOG_(INFO) << "ProcessDumpTest027: end.";
566 }
567
568 /**
569 * @tc.name: ProcessDumpTest028
570 * @tc.desc: test get dump context
571 * @tc.type: FUNC
572 */
573 HWTEST_F (ProcessDumpTest, ProcessDumpTest028, TestSize.Level2)
574 {
575 GTEST_LOG_(INFO) << "ProcessDumpTest028: start.";
576 std::shared_ptr<ProcessDumpRequest> processDump = std::make_shared<ProcessDumpRequest>();
577 ucontext_t inputContext;
578 inputContext.uc_flags = 3.0;
579 if (processDump != nullptr) {
580 processDump->SetContext(inputContext);
581 }
582 ucontext_t outputContext = processDump->GetContext();
583 EXPECT_EQ(true, outputContext.uc_flags == inputContext.uc_flags) << "ProcessDumpTest028 Failed";
584 GTEST_LOG_(INFO) << "ProcessDumpTest028: end.";
585 }
586
587 /**
588 * @tc.name: ProcessDumpTest029
589 * @tc.desc: test if signal info is available
590 * @tc.type: FUNC
591 */
592 HWTEST_F (ProcessDumpTest, ProcessDumpTest029, TestSize.Level2)
593 {
594 GTEST_LOG_(INFO) << "ProcessDumpTest029: start.";
595 int32_t input = 1;
596 std::shared_ptr<DfxSignal> signal = std::make_shared<DfxSignal>(input);
597 bool ret = false;
598 if (signal != nullptr) {
599 ret = signal->IsAvailable();
600 }
601 EXPECT_EQ(true, ret != true) << "ProcessDumpTest029 Failed";
602 GTEST_LOG_(INFO) << "ProcessDumpTest029: end.";
603 }
604
605 /**
606 * @tc.name: ProcessDumpTest030
607 * @tc.desc: test if addr is available
608 * @tc.type: FUNC
609 */
610 HWTEST_F (ProcessDumpTest, ProcessDumpTest030, TestSize.Level2)
611 {
612 GTEST_LOG_(INFO) << "ProcessDumpTest030: start.";
613 int32_t input = -100;
614 std::shared_ptr<DfxSignal> signal = std::make_shared<DfxSignal>(input);
615 bool ret = false;
616 if (signal != nullptr) {
617 ret = signal->IsAddrAvailable();
618 }
619 EXPECT_EQ(true, ret != true) << "ProcessDumpTest030 Failed";
620 GTEST_LOG_(INFO) << "ProcessDumpTest030: end.";
621 }
622
623 /**
624 * @tc.name: ProcessDumpTest031
625 * @tc.desc: test if pid is available
626 * @tc.type: FUNC
627 */
628 HWTEST_F (ProcessDumpTest, ProcessDumpTest031, TestSize.Level2)
629 {
630 int32_t input = 100;
631 GTEST_LOG_(INFO) << "ProcessDumpTest031: start.";
632 std::shared_ptr<DfxSignal> signal = std::make_shared<DfxSignal>(input);
633 bool ret = false;
634 if (signal != nullptr) {
635 ret = signal->IsPidAvailable();
636 }
637 EXPECT_EQ(true, ret != true) << "ProcessDumpTest031 Failed";
638 GTEST_LOG_(INFO) << "ProcessDumpTest031: end.";
639 }
640
641 /**
642 * @tc.name: ProcessDumpTest032
643 * @tc.desc: test if pid is available
644 * @tc.type: FUNC
645 */
646 HWTEST_F (ProcessDumpTest, ProcessDumpTest032, TestSize.Level2)
647 {
648 GTEST_LOG_(INFO) << "ProcessDumpTest032: start.";
649 int32_t input = 1;
650 std::shared_ptr<DfxSignal> signal = std::make_shared<DfxSignal>(input);
651 int32_t output = 0;
652 if (signal != nullptr) {
653 output = signal->GetSignal();
654 }
655 EXPECT_EQ(true, output == input) << "ProcessDumpTest032 Failed";
656 GTEST_LOG_(INFO) << "ProcessDumpTest032: end.";
657 }
658
659 /**
660 * @tc.name: ProcessDumpTest033
661 * @tc.desc: test get process id
662 * @tc.type: FUNC
663 */
664 HWTEST_F (ProcessDumpTest, ProcessDumpTest033, TestSize.Level2)
665 {
666 GTEST_LOG_(INFO) << "ProcessDumpTest033: start.";
667 int32_t pid = 1, tid = 1;
668 ucontext_t context;
669 std::shared_ptr<DfxThread> thread = std::make_shared<DfxThread>(pid, tid, tid, context);
670 pid_t processID = thread->GetProcessId();
671 GTEST_LOG_(INFO) << "ProcessDumpTest033: result = " << processID;
672 EXPECT_EQ(true, pid == processID) << "ProcessDumpTest033 failed";
673 GTEST_LOG_(INFO) << "ProcessDumpTest033: end.";
674 }
675
676 /**
677 * @tc.name: ProcessDumpTest034
678 * @tc.desc: test get thread id
679 * @tc.type: FUNC
680 */
681 HWTEST_F (ProcessDumpTest, ProcessDumpTest034, TestSize.Level2)
682 {
683 GTEST_LOG_(INFO) << "ProcessDumpTest034: start.";
684 int32_t pid = 243, tid = 243;
685 ucontext_t context;
686 std::shared_ptr<DfxThread> thread = std::make_shared<DfxThread>(pid, tid, tid, context);
687 pid_t threadId = thread->GetThreadId();
688 GTEST_LOG_(INFO) << "ProcessDumpTest034: result = " << threadId;
689 EXPECT_EQ(true, tid == threadId) << "ProcessDumpTest034 failed";
690 GTEST_LOG_(INFO) << "ProcessDumpTest034: end.";
691 }
692
693 /**
694 * @tc.name: ProcessDumpTest035
695 * @tc.desc: test get thread name
696 * @tc.type: FUNC
697 */
698 HWTEST_F (ProcessDumpTest, ProcessDumpTest035, TestSize.Level2)
699 {
700 GTEST_LOG_(INFO) << "ProcessDumpTest035: start.";
701 int32_t pid = 243, tid = 243;
702 std::shared_ptr<DfxThread> thread = std::make_shared<DfxThread>(pid, tid, tid);
703 pid_t threadId = thread->GetThreadId();
704 EXPECT_EQ(true, threadId == tid) << "ProcessDumpTest035 failed";
705 GTEST_LOG_(INFO) << "ProcessDumpTest035: end.";
706 }
707
708 /**
709 * @tc.name: ProcessDumpTest036
710 * @tc.desc: test get thread name
711 * @tc.type: FUNC
712 */
713 HWTEST_F (ProcessDumpTest, ProcessDumpTest036, TestSize.Level2)
714 {
715 GTEST_LOG_(INFO) << "ProcessDumpTest036: start.";
716 int32_t pid = 1, tid = 1;
717 std::shared_ptr<DfxThread> thread = std::make_shared<DfxThread>(pid, tid, tid);
718 std::string threadName = thread->GetThreadName();
719 EXPECT_EQ(true, threadName != "");
720 GTEST_LOG_(INFO) << "ProcessDumpTest036: result = " << threadName;
721 GTEST_LOG_(INFO) << "ProcessDumpTest036: end.";
722 }
723
724 /**
725 * @tc.name: ProcessDumpTest037
726 * @tc.desc: test get DfxRegs
727 * @tc.type: FUNC
728 */
729 HWTEST_F (ProcessDumpTest, ProcessDumpTest037, TestSize.Level2)
730 {
731 GTEST_LOG_(INFO) << "ProcessDumpTest037: start.";
732 int32_t pid = 243, tid = 243;
733 std::shared_ptr<DfxThread> thread = std::make_shared<DfxThread>(pid, tid, tid);
734 std::shared_ptr<DfxRegs> inputrefs;
735 thread->SetThreadRegs(inputrefs);
736 std::shared_ptr<DfxRegs> outputrefs= thread->GetThreadRegs();
737 EXPECT_EQ(true, inputrefs == outputrefs) << "ProcessDumpTest037 Failed";
738 GTEST_LOG_(INFO) << "ProcessDumpTest037: end.";
739 }
740
741 /**
742 * @tc.name: ProcessDumpTest038
743 * @tc.desc: test get DfxFrame
744 * @tc.type: FUNC
745 */
746 HWTEST_F (ProcessDumpTest, ProcessDumpTest038, TestSize.Level2)
747 {
748 GTEST_LOG_(INFO) << "ProcessDumpTest038: start.";
749 int32_t pid = 243, tid = 243;
750 std::shared_ptr<DfxThread> thread = std::make_shared<DfxThread>(pid, tid, tid);
751 std::shared_ptr<DfxFrame> outputrefs= thread->GetAvailableFrame();
752 EXPECT_EQ(true, outputrefs != nullptr) << "ProcessDumpTest038 Failed";
753 GTEST_LOG_(INFO) << "ProcessDumpTest038: end.";
754 }
755
756 /**
757 * @tc.name: ProcessDumpTest039
758 * @tc.desc: test UnwindProcess
759 * @tc.type: FUNC
760 */
761 HWTEST_F (ProcessDumpTest, ProcessDumpTest039, TestSize.Level2)
762 {
763 GTEST_LOG_(INFO) << "ProcessDumpTest039: start.";
764 std::shared_ptr<DfxProcess> process = std::make_shared<DfxProcess>();
765 pid_t pid = GetProcessPid("accountmgr");
766 pid_t tid = pid;
767 std::shared_ptr<DfxThread> thread = std::make_shared<DfxThread>(pid, tid, tid);
768 const std::vector<std::shared_ptr<DfxThread>> threads = { thread };
769 process->SetThreads(threads);
770 thread->Attach();
771 bool ret = DfxUnwindRemote::GetInstance().UnwindProcess(process);
772 thread->Detach();
773 EXPECT_EQ(true, ret) << "ProcessDumpTest039 Failed";
774 GTEST_LOG_(INFO) << "ProcessDumpTest039: end.";
775 }
776
777 /**
778 * @tc.name: ProcessDumpTest040
779 * @tc.desc: test UnwindThread
780 * @tc.type: FUNC
781 */
782 HWTEST_F (ProcessDumpTest, ProcessDumpTest040, TestSize.Level2)
783 {
784 GTEST_LOG_(INFO) << "ProcessDumpTest040: start.";
785 std::shared_ptr<DfxProcess> process = std::make_shared<DfxProcess>();
786 pid_t pid = GetProcessPid("accountmgr");
787 pid_t tid = pid;
788 std::shared_ptr<DfxThread> thread = std::make_shared<DfxThread>(pid, tid, tid);
789 thread->Attach();
790 bool ret = DfxUnwindRemote::GetInstance().UnwindThread(process, thread);
791 thread->Detach();
792 EXPECT_EQ(true, ret) << "ProcessDumpTest040 Failed";
793 GTEST_LOG_(INFO) << "ProcessDumpTest040: end.";
794 }
795 }
796