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