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 #include <fcntl.h>
16 #include <gtest/gtest.h>
17 #define private public
18 #include "executor/memory_dumper.h"
19 #include "executor/api_dumper.h"
20 #include "executor/cmd_dumper.h"
21 #include "executor/cpu_dumper.h"
22 #include "executor/file_stream_dumper.h"
23 #include "executor/ipc_stat_dumper.h"
24 #include "executor/jsheap_memory_dumper.h"
25 #include "executor/list_dumper.h"
26 #include "executor/sa_dumper.h"
27 #include "executor/version_dumper.h"
28 #include "executor/traffic_dumper.h"
29 #include "util/config_utils.h"
30 #include "util/string_utils.h"
31 #include "manager/dump_implement.h"
32 #undef private
33 
34 using namespace std;
35 using namespace testing::ext;
36 using namespace OHOS;
37 using namespace OHOS::HiviewDFX;
38 namespace OHOS {
39 namespace HiviewDFX {
40 static std::shared_ptr<DumperParameter> g_parameter;
41 static std::shared_ptr<std::vector<std::vector<std::string>>> g_dump_datas;
42 static std::shared_ptr<DumpCfg> g_config;
43 class HidumperDumpersTest : public testing::Test {
44 public:
45     static void SetUpTestCase(void);
46     static void TearDownTestCase(void);
47     void SetUp();
48     void TearDown();
49     static void HandleDumperComon(std::string dumperType);
50     static void HandleDumperExcute(std::string dumperType);
51     static void HandleCpuDumperTest(int pid);
52     static void HandleMemoryDumperTest(int pid);
53     static void HandleTrafficDumperTest(int pid);
54     static void GetDumperVariable();
55     static void HandleIpcStatDumperTest(void);
56     static DumpStatus SetIpcStatCmdTest(const DumperOpts &opts);
57 
58 protected:
59     static constexpr auto& FILE_CPUINFO = "/proc/cpuinfo";
60     static constexpr auto DEFAULT_PID = 1;
61     static constexpr auto DEFAULT_UID = 0;
62 };
63 
SetUpTestCase(void)64 void HidumperDumpersTest::SetUpTestCase(void)
65 {
66 }
67 
TearDownTestCase(void)68 void HidumperDumpersTest::TearDownTestCase(void)
69 {
70 }
71 
SetUp(void)72 void HidumperDumpersTest::SetUp(void)
73 {
74     GetDumperVariable();
75 }
76 
TearDown(void)77 void HidumperDumpersTest::TearDown(void)
78 {
79 }
80 
GetDumperVariable()81 void HidumperDumpersTest::GetDumperVariable()
82 {
83     g_parameter = std::make_shared<DumperParameter>();
84     g_dump_datas = std::make_shared<std::vector<std::vector<std::string>>>();
85     g_config = std::make_shared<DumpCfg>();
86 }
87 
HandleDumperExcute(std::string dumperType)88 void HidumperDumpersTest::HandleDumperExcute(std::string dumperType)
89 {
90     std::shared_ptr<HidumperExecutor> dumper = std::make_shared<FileStreamDumper>();
91     if (StringUtils::GetInstance().IsSameStr(dumperType, "APIDumper")) {
92         dumper = std::make_shared<APIDumper>();
93     } else if (StringUtils::GetInstance().IsSameStr(dumperType, "VersionDumper")) {
94         dumper = std::make_shared<VersionDumper>();
95     } else if (StringUtils::GetInstance().IsSameStr(dumperType, "CMDDumper")) {
96         dumper = std::make_shared<CMDDumper>();
97     } else if (StringUtils::GetInstance().IsSameStr(dumperType, "SADumper")) {
98         dumper = std::make_shared<SADumper>();
99     } else {
100         dumper = std::make_shared<ListDumper>();
101     }
102     dumper->SetDumpConfig(g_config);
103     if (StringUtils::GetInstance().IsSameStr(dumperType, "SADumper")
104         || StringUtils::GetInstance().IsSameStr(dumperType, "ListDumper")) {
105         int fd = open("/dev/null", O_RDWR | O_CREAT | O_TRUNC, 0664);
106         if (fd <= 0) {
107             fd = STDERR_FILENO;
108         }
109         std::vector<std::u16string> args;
110         std::shared_ptr<RawParam> rawParam = std::make_shared<RawParam>(0, 1, 0, args, fd);
111         g_parameter->setClientCallback(rawParam);
112         DumpStatus ret = DumpStatus::DUMP_FAIL;
113         ret = dumper->PreExecute(g_parameter, g_dump_datas);
114         ASSERT_EQ(ret, DumpStatus::DUMP_OK);
115         ret = dumper->Execute();
116         ASSERT_EQ(ret, DumpStatus::DUMP_OK);
117         if (StringUtils::GetInstance().IsSameStr(dumperType, "ListDumper")) {
118             ret = dumper->AfterExecute();
119             ASSERT_EQ(ret, DumpStatus::DUMP_OK);
120         }
121     } else {
122         DumpStatus ret = dumper->DoPreExecute(g_parameter, g_dump_datas);
123         ASSERT_TRUE(ret == DumpStatus::DUMP_OK) << "PreExecute failed.";
124         ret = dumper->DoExecute();
125         ASSERT_TRUE(ret == DumpStatus::DUMP_OK) << "Execute failed.";
126         ret = dumper->DoAfterExecute();
127         ASSERT_TRUE(ret == DumpStatus::DUMP_OK) << "AfterExecute failed.";
128     }
129 }
130 
HandleCpuDumperTest(int pid)131 void HidumperDumpersTest::HandleCpuDumperTest(int pid)
132 {
133     auto parameter = std::make_shared<DumperParameter>();
134     DumperOpts opts;
135     opts.isDumpCpuUsage_ = pid == -1 ? true : false;
136     opts.cpuUsagePid_ = pid;
137     parameter->SetOpts(opts);
138     auto dumpDatas = std::make_shared<std::vector<std::vector<std::string>>>();
139     auto cpuDumper = std::make_shared<CPUDumper>();
140     DumpStatus ret = DumpStatus::DUMP_FAIL;
141     ret = cpuDumper->PreExecute(parameter, dumpDatas);
142     ASSERT_EQ(ret, DumpStatus::DUMP_OK);
143     ret = cpuDumper->Execute();
144     if (pid == -1) {
145         ASSERT_EQ(ret, DumpStatus::DUMP_OK);
146         ret = cpuDumper->AfterExecute();
147         ASSERT_EQ(ret, DumpStatus::DUMP_OK);
148     } else {
149         ASSERT_EQ(ret, DumpStatus::DUMP_FAIL);
150     }
151 }
152 
153 
HandleMemoryDumperTest(int pid)154 void HidumperDumpersTest::HandleMemoryDumperTest(int pid)
155 {
156     auto memoryDumper = std::make_shared<MemoryDumper>();
157     memoryDumper->pid_ = pid;
158     auto dumpDatas = std::make_shared<std::vector<std::vector<std::string>>>();
159     memoryDumper->dumpDatas_ = dumpDatas;
160     int res = DumpStatus::DUMP_MORE_DATA;
161     while (res == DumpStatus::DUMP_MORE_DATA) {
162         res = memoryDumper->Execute();
163     }
164     ASSERT_EQ(res, DumpStatus::DUMP_OK);
165 }
166 
HandleTrafficDumperTest(int pid)167 void HidumperDumpersTest::HandleTrafficDumperTest(int pid)
168 {
169     auto trafficDumper = std::make_shared<TrafficDumper>();
170     trafficDumper->pid_ = pid;
171     auto dumpDatas = std::make_shared<std::vector<std::vector<std::string>>>();
172     ASSERT_NE(dumpDatas, nullptr);
173     trafficDumper->result_ = dumpDatas;
174     DumpStatus ret = DumpStatus::DUMP_FAIL;
175     ret = trafficDumper->Execute();
176     ASSERT_EQ(ret, DumpStatus::DUMP_OK);
177     ret = trafficDumper->AfterExecute();
178     ASSERT_EQ(ret, DumpStatus::DUMP_OK);
179 }
180 
HandleDumperComon(std::string dumperType)181 void HidumperDumpersTest::HandleDumperComon(std::string dumperType)
182 {
183     std::shared_ptr<HidumperExecutor> dumper = std::make_shared<FileStreamDumper>();
184     if (StringUtils::GetInstance().IsSameStr(dumperType, "CMDDumper")) {
185         dumper = std::make_shared<CMDDumper>();
186     }
187     dumper->SetDumpConfig(g_config);
188     DumpStatus ret = dumper->DoPreExecute(g_parameter, g_dump_datas);
189     ASSERT_TRUE(ret == DumpStatus::DUMP_OK) << "PreExecute failed.";
190     ret = DumpStatus::DUMP_MORE_DATA;
191     while (ret == DumpStatus::DUMP_MORE_DATA) {
192         // loop for all lines
193         ret = dumper->DoExecute();
194         ASSERT_TRUE(ret == DumpStatus::DUMP_OK || ret == DumpStatus::DUMP_MORE_DATA) << "Execute failed.";
195         ret = dumper->DoAfterExecute();
196         ASSERT_TRUE(ret == DumpStatus::DUMP_OK || ret == DumpStatus::DUMP_MORE_DATA) << "Execute failed.";
197     }
198 }
199 
HandleIpcStatDumperTest(void)200 void HidumperDumpersTest::HandleIpcStatDumperTest(void)
201 {
202     auto parameter = std::make_shared<DumperParameter>();
203     std::vector<std::u16string> args;
204     DumperOpts opts;
205     auto dumpDatas = std::make_shared<std::vector<std::vector<std::string>>>();
206     auto ipcStatDumper = std::make_shared<IPCStatDumper>();
207 
208     int fd = open("/dev/null", O_RDWR | O_CREAT | O_TRUNC, 0664);
209     if (fd <= 0) {
210         fd = STDERR_FILENO;
211     }
212     std::shared_ptr<RawParam> rawParam = std::make_shared<RawParam>(0, 1, 0, args, fd);
213 
214     opts.isDumpIpc_ = true;
215     opts.isDumpAllIpc_ = true;
216     opts.isDumpIpcStartStat_ = true;
217     parameter->SetOpts(opts);
218     parameter->setClientCallback(rawParam);
219 
220     DumpStatus ret = DumpStatus::DUMP_FAIL;
221     ret = ipcStatDumper->PreExecute(parameter, dumpDatas);
222     ASSERT_EQ(ret, DumpStatus::DUMP_OK);
223     ret = ipcStatDumper->Execute();
224     ASSERT_EQ(ret, DumpStatus::DUMP_OK);
225     ret = ipcStatDumper->AfterExecute();
226     ASSERT_EQ(ret, DumpStatus::DUMP_OK);
227 }
228 
SetIpcStatCmdTest(const DumperOpts & opts)229 DumpStatus HidumperDumpersTest::SetIpcStatCmdTest(const DumperOpts &opts)
230 {
231     auto parameter = std::make_shared<DumperParameter>();
232     std::vector<std::u16string> args;
233     auto dumpDatas = std::make_shared<std::vector<std::vector<std::string>>>();
234     auto ipcStatDumper = std::make_shared<IPCStatDumper>();
235 
236     int fd = open("/dev/null", O_RDWR | O_CREAT | O_TRUNC, 0664);
237     if (fd <= 0) {
238         fd = STDERR_FILENO;
239     }
240     std::shared_ptr<RawParam> rawParam = std::make_shared<RawParam>(0, 1, 0, args, fd);
241     parameter->SetOpts(opts);
242     parameter->setClientCallback(rawParam);
243 
244     DumpStatus ret = DumpStatus::DUMP_FAIL;
245     ret = ipcStatDumper->PreExecute(parameter, dumpDatas);
246     if (ret != DumpStatus::DUMP_OK) {
247         return ret;
248     }
249     ret = ipcStatDumper->Execute();
250     return ret;
251 }
252 
253 /**
254  * @tc.name: FileDumperTest001
255  * @tc.desc: Test FileDumper base function with loop = TRUE.
256  * @tc.type: FUNC
257  */
258 HWTEST_F(HidumperDumpersTest, FileDumperTest001, TestSize.Level3)
259 {
260     g_config->name_ = "FileDumperTest";
261     std::string file_name = FILE_CPUINFO;
262     g_config->target_ = file_name;
263     g_config->loop_ = DumperConstant::LOOP;
264     g_config->args_ = OptionArgs::Create();
265     g_config->args_->SetPid(DEFAULT_PID, DEFAULT_UID);
266     g_config->args_->SetCpuId(0);
267     HandleDumperComon("FileStreamDumper");
268 }
269 
270 /**
271  * @tc.name: FileDumperTest002
272  * @tc.desc: Test FileDumper base function with loop = FALSE.
273  * @tc.type: FUNC
274  */
275 HWTEST_F(HidumperDumpersTest, FileDumperTest002, TestSize.Level3)
276 {
277     g_config->name_ = "FileDumperTest";
278     std::string file_name = FILE_CPUINFO;
279     g_config->target_ = file_name;
280     g_config->loop_ = DumperConstant::NONE;
281     HandleDumperComon("FileStreamDumper");
282 }
283 
284 /**
285  * @tc.name: FileDumperTest005
286  * @tc.desc: Test FileDumper base function with replacing PID in file paths.
287  * @tc.type: FUNC
288  */
289 HWTEST_F(HidumperDumpersTest, FileDumperTest005, TestSize.Level0)
290 {
291     g_config->name_ = "FileDumperTest";
292     std::string file_name = "/proc/%pid/smaps";
293     g_config->target_ = file_name;
294     g_config->loop_ = DumperConstant::LOOP;
295     g_config->args_ = OptionArgs::Create();
296     g_config->args_->SetPid(DEFAULT_PID, DEFAULT_UID);
297     g_config->args_->SetCpuId(1);
298     HandleDumperComon("FileStreamDumper");
299 }
300 
301 /**
302  * @tc.name: APIDumperTest001
303  * @tc.desc: Test APIDumper target is build_version.
304  * @tc.type: FUNC
305  */
306 HWTEST_F(HidumperDumpersTest, APIDumperTest001, TestSize.Level3)
307 {
308     g_config->name_ = "dumper_build_id";
309     g_config->target_ = "build_version";
310     HandleDumperExcute("APIDumper");
311 }
312 
313 /**
314  * @tc.name: APIDumperTest002
315  * @tc.desc: Test APIDumper target is hw_sc.build.os.releasetype.
316  * @tc.type: FUNC
317  */
318 HWTEST_F(HidumperDumpersTest, APIDumperTest002, TestSize.Level3)
319 {
320     g_config->name_ = "dumper_release_type";
321     g_config->target_ = "hw_sc.build.os.releasetype";
322     HandleDumperExcute("APIDumper");
323 }
324 
325 /**
326  * @tc.name: APIDumperTest003
327  * @tc.desc: Test APIDumper target is hw_sc.build.os.version.
328  * @tc.type: FUNC
329  */
330 HWTEST_F(HidumperDumpersTest, APIDumperTest003, TestSize.Level3)
331 {
332     g_config->name_ = "dumper_os_version";
333     g_config->target_ = "hw_sc.build.os.version";
334     HandleDumperExcute("APIDumper");
335 }
336 
337 /**
338  * @tc.name: APIDumperTest004
339  * @tc.desc: Test APIDumper target is system_param.
340  * @tc.type: FUNC
341  */
342 HWTEST_F(HidumperDumpersTest, APIDumperTest004, TestSize.Level3)
343 {
344     g_config->name_ = "dumper_system_param";
345     g_config->target_ = "system_param";
346     HandleDumperExcute("APIDumper");
347 }
348 
349 /**
350  * @tc.name: VersionDumperTest001
351  * @tc.desc: Test VersionDumper.
352  * @tc.type: FUNC
353  */
354 HWTEST_F(HidumperDumpersTest, VersionDumperTest001, TestSize.Level3)
355 {
356     HandleDumperExcute("VersionDumper");
357 }
358 
359 /**
360  * @tc.name: CMDDumperTest001
361  * @tc.desc: CMD Dumper base function with loop = TRUE.
362  * @tc.type: FUNC
363  */
364 HWTEST_F(HidumperDumpersTest, CMDDumperTest001, TestSize.Level3)
365 {
366     g_config->name_ = "CmdDumperTest";
367     std::string cmd = "ps -ef";
368     g_config->target_ = cmd;
369     g_config->loop_ = DumperConstant::LOOP;
370     HandleDumperComon("CMDDumper");
371 }
372 
373 /**
374  * @tc.name: CMDDumperTest002
375  * @tc.desc: CMD Dumper base function with loop = False.
376  * @tc.type: FUNC
377  */
378 HWTEST_F(HidumperDumpersTest, CMDDumperTest002, TestSize.Level3)
379 {
380     g_config->name_ = "CmdDumperTest";
381     std::string cmd = "ps -ef";
382     g_config->target_ = cmd;
383     g_config->loop_ = DumperConstant::NONE;
384     HandleDumperComon("CMDDumper");
385 }
386 
387 /**
388  * @tc.name: CMDDumperTest003
389  * @tc.desc: CMD Dumper GetCmdInterface.
390  * @tc.type: FUNC
391  */
392 HWTEST_F(HidumperDumpersTest, CMDDumperTest003, TestSize.Level3)
393 {
394     auto dumpDatas = std::make_shared<std::vector<std::vector<std::string>>>();
395     auto cmdDumper = std::make_shared<CMDDumper>();
396 
397     int ret = cmdDumper->GetCmdInterface("hidumper --mem 1", dumpDatas);
398     ASSERT_EQ(ret, DumpStatus::DUMP_OK);
399 }
400 
401 /**
402  * @tc.name: MemoryDumperTest001
403  * @tc.desc: Test MemoryDumper one process has correct ret.
404  * @tc.type: FUNC
405  */
406 HWTEST_F(HidumperDumpersTest, MemoryDumperTest001, TestSize.Level1)
407 {
408     HandleMemoryDumperTest(1);
409 }
410 
411 /**
412  * @tc.name: MemoryDumperTest002
413  * @tc.desc: Test MemoryDumper all process has correct ret.
414  * @tc.type: FUNC
415  */
416 HWTEST_F(HidumperDumpersTest, MemoryDumperTest002, TestSize.Level1)
417 {
418     HandleMemoryDumperTest(-1);
419 }
420 
421 /**
422  * @tc.name: SADumperTest001
423  * @tc.desc: Test SADumper no saname has correct ret.
424  * @tc.type: FUNC
425  */
426 HWTEST_F(HidumperDumpersTest, SADumperTest001, TestSize.Level1)
427 {
428     g_config->args_ = OptionArgs::Create();
429     HandleDumperExcute("SADumper");
430 }
431 
432 /**
433  * @tc.name: SADumperTest002
434  * @tc.desc: Test SADumper one saname has correct ret.
435  * @tc.type: FUNC
436  */
437 HWTEST_F(HidumperDumpersTest, SADumperTest002, TestSize.Level1)
438 {
439     g_config->args_ = OptionArgs::Create();
440     const std::vector<std::string> names = {"1202"};
441     const std::vector<std::string> args;
442     g_config->args_->SetNamesAndArgs(names, args);
443     HandleDumperExcute("SADumper");
444 }
445 
446 /**
447  * @tc.name: CpuDumperTest001
448  * @tc.desc: Test CpuDumper dump all process has correct ret.
449  * @tc.type: FUNC
450  */
451 HWTEST_F(HidumperDumpersTest, CpuDumperTest001, TestSize.Level1)
452 {
453     HandleCpuDumperTest(-1);
454 }
455 
456 /**
457  * @tc.name: CpuDumperTest002
458  * @tc.desc: Test CpuDumper has correct ret when opts is vaild.
459  * @tc.type: FUNC
460  */
461 HWTEST_F(HidumperDumpersTest, CpuDumperTest002, TestSize.Level1)
462 {
463     HandleCpuDumperTest(getpid());
464 }
465 
466 /**
467  * @tc.name: ListDumperTest001
468  * @tc.desc: Test ListDumper dump ABILITY has correct ret.
469  * @tc.type: FUNC
470  */
471 HWTEST_F(HidumperDumpersTest, ListDumperTest001, TestSize.Level1)
472 {
473     g_config->target_ = ConfigUtils::STR_ABILITY;
474     HandleDumperExcute("ListDumper");
475 }
476 
477 /**
478  * @tc.name: ListDumperTest002
479  * @tc.desc: Test ListDumper dump SYSTEM has correct ret.
480  * @tc.type: FUNC
481  */
482 HWTEST_F(HidumperDumpersTest, ListDumperTest002, TestSize.Level1)
483 {
484     g_config->target_ = ConfigUtils::STR_SYSTEM;
485     HandleDumperExcute("ListDumper");
486 }
487 
488 /**
489  * @tc.name: TrafficDumperTest001
490  * @tc.desc: Test TrafficDumper dump valid process traffic information.
491  * @tc.type: FUNC
492  */
493 HWTEST_F(HidumperDumpersTest, TrafficDumperTest001, TestSize.Level1)
494 {
495     HandleTrafficDumperTest(1);
496 }
497 
498 /**
499  * @tc.name: TrafficDumperTest002
500  * @tc.desc: Test TrafficDumper dump invalid process traffic information.
501  * @tc.type: FUNC
502  */
503 HWTEST_F(HidumperDumpersTest, TrafficDumperTest002, TestSize.Level1)
504 {
505     HandleTrafficDumperTest(-1);
506 }
507 
508 /**
509  * @tc.name: IpcStatDumperTest001
510  * @tc.desc: Test IpcDumper dump all processes.
511  * @tc.type: FUNC
512  */
513 HWTEST_F(HidumperDumpersTest, IpcStatDumperTest001, TestSize.Level1)
514 {
515     HandleIpcStatDumperTest();
516 }
517 
518 /**
519  * @tc.name: IpcStatDumperTest002
520  * @tc.desc: Test IpcDumper CheckPidIsSa failed.
521  * @tc.type: FUNC
522  */
523 HWTEST_F(HidumperDumpersTest, IpcStatDumperTest002, TestSize.Level1)
524 {
525     auto parameter = std::make_shared<DumperParameter>();
526     std::vector<std::string> args;
527     DumperOpts opts;
528     auto dumpDatas = std::make_shared<std::vector<std::vector<std::string>>>();
529     auto ipcStatDumper = std::make_shared<IPCStatDumper>();
530 
531     sptr<ISystemAbilityManager> sam = nullptr;
532     sptr<IRemoteObject> sa = nullptr;
533     bool ret = ipcStatDumper->CheckPidIsSa(sam, args, sa);
534     ASSERT_EQ(ret, false);
535 }
536 
537 /**
538  * @tc.name: IpcStatDumperTest004
539  * @tc.desc: Test IpcDumper dump with invaid pid.
540  * @tc.type: FUNC
541  */
542 HWTEST_F(HidumperDumpersTest, IpcStatDumperTest004, TestSize.Level1)
543 {
544     DumperOpts opts;
545     opts.isDumpIpc_ = true;
546     opts.isDumpAllIpc_ = false;
547     opts.ipcStatPid_ = DEFAULT_PID;
548     opts.isDumpIpcStartStat_ = true;
549     DumpStatus ret = SetIpcStatCmdTest(opts);
550     ASSERT_EQ(ret, DumpStatus::DUMP_FAIL);
551 }
552 
553 /**
554  * @tc.name: IpcStatDumperTest005
555  * @tc.desc: Test IpcDumper with invalid cmd;
556  * @tc.type: FUNC
557  */
558 HWTEST_F(HidumperDumpersTest, IpcStatDumperTest005, TestSize.Level1)
559 {
560     DumperOpts opts;
561     opts.isDumpIpc_ = true;
562     opts.isDumpAllIpc_ = true;
563     opts.isDumpIpcStartStat_ = false;
564     opts.isDumpIpcStopStat_ = false;
565     opts.isDumpIpcStat_ = false;
566     DumpStatus ret = SetIpcStatCmdTest(opts);
567     ASSERT_EQ(ret, DumpStatus::DUMP_FAIL);
568 }
569 
570 /**
571  * @tc.name: IpcStatDumperTest006
572  * @tc.desc: Test IpcDumper CheckPidIsApp.
573  * @tc.type: FUNC
574  */
575 HWTEST_F(HidumperDumpersTest, IpcStatDumperTest006, TestSize.Level1)
576 {
577     std::vector<std::string> args;
578     auto ipcStatDumper = std::make_shared<IPCStatDumper>();
579     sptr<ISystemAbilityManager> sam = nullptr;
580     sptr<IRemoteObject> sa = nullptr;
581     bool ret = ipcStatDumper->CheckPidIsApp(sam, args, sa);
582     ASSERT_EQ(ret, false);
583 }
584 
585 /**
586  * @tc.name: IpcStatDumperTest007
587  * @tc.desc: Test IpcDumper DumpIpcStat.
588  * @tc.type: FUNC
589  */
590 HWTEST_F(HidumperDumpersTest, IpcStatDumperTest007, TestSize.Level1)
591 {
592     auto ipcStatDumper = std::make_shared<IPCStatDumper>();
593     sptr<ISystemAbilityManager> sam = nullptr;
594     sptr<IRemoteObject> sa = nullptr;
595     DumpStatus ret = ipcStatDumper->DumpIpcStat(sam, sa);
596     ASSERT_EQ(ret, DumpStatus::DUMP_FAIL);
597 }
598 
599 /**
600  * @tc.name: IpcStatDumperTest008
601  * @tc.desc: Test IpcDumper ptrReqCtl_ is nullptr.
602  * @tc.type: FUNC
603  */
604 HWTEST_F(HidumperDumpersTest, IpcStatDumperTest008, TestSize.Level1)
605 {
606     auto parameter = std::make_shared<DumperParameter>();
607     std::vector<std::u16string> args;
608     DumperOpts opts;
609     auto dumpDatas = std::make_shared<std::vector<std::vector<std::string>>>();
610     auto ipcStatDumper = std::make_shared<IPCStatDumper>();
611 
612     int fd = open("/dev/null", O_RDWR | O_CREAT | O_TRUNC, 0664);
613     if (fd <= 0) {
614         fd = STDERR_FILENO;
615     }
616 
617     opts.isDumpIpc_ = true;
618     opts.isDumpAllIpc_ = true;
619     opts.isDumpIpcStartStat_ = true;
620     parameter->SetOpts(opts);
621     parameter->setClientCallback(nullptr);
622 
623     DumpStatus ret = DumpStatus::DUMP_FAIL;
624     ret = ipcStatDumper->PreExecute(parameter, dumpDatas);
625     ret = ipcStatDumper->Execute();
626     ipcStatDumper->SendErrorMessage("ptrReqCtl_ test");
627     ASSERT_EQ(ret, DumpStatus::DUMP_FAIL);
628 }
629 
630 /**
631  * @tc.name: IpcStatDumperTest009
632  * @tc.desc: Test IpcDumper DoDumpIpcStat with sa nullptr.
633  * @tc.type: FUNC
634  */
635 HWTEST_F(HidumperDumpersTest, IpcStatDumperTest009, TestSize.Level1)
636 {
637     auto ipcStatDumper = std::make_shared<IPCStatDumper>();
638     sptr<IRemoteObject> sa = nullptr;
639     DumpStatus ret = ipcStatDumper->DoDumpIpcStat(sa);
640     ASSERT_EQ(ret, DumpStatus::DUMP_FAIL);
641 }
642 
643 
644 /**
645  * @tc.name: IpcStatDumperTest009
646  * @tc.desc: Test IpcDumper with invalid rawParamFd.
647  * @tc.type: FUNC
648  */
649 HWTEST_F(HidumperDumpersTest, IpcStatDumperTest010, TestSize.Level1)
650 {
651     char *argv[] = {
652         const_cast<char *>("hidumper"),
653         const_cast<char *>("--ipc"),
654         const_cast<char *>("1"),
655         const_cast<char *>("--start-stat"),
656     };
657     int argc = sizeof(argv) / sizeof(argv[0]);
658     std::vector<std::u16string> args;
659     std::shared_ptr<RawParam> rawParam = std::make_shared<RawParam>(0, 1, 0, args, -1);
660     int ret = DumpImplement::GetInstance().Main(argc, argv, rawParam);
661     ASSERT_EQ(ret, DumpStatus::DUMP_OK);
662 }
663 
664 /**
665  * @tc.name: JsHeapDumperTest001
666  * @tc.desc: Test JsHeapDumper with init pid
667  * @tc.type: FUNC
668  */
669 HWTEST_F(HidumperDumpersTest, JsHeapDumperTest001, TestSize.Level1)
670 {
671     char *argv[] = {
672         const_cast<char *>("hidumper"),
673         const_cast<char *>("--mem-jsheap"),
674         const_cast<char *>("1"),
675     };
676     int argc = sizeof(argv) / sizeof(argv[0]);
677     std::vector<std::u16string> args;
678     std::shared_ptr<RawParam> rawParam = std::make_shared<RawParam>(0, 1, 0, args, -1);
679     int ret = DumpImplement::GetInstance().Main(argc, argv, rawParam);
680     ASSERT_EQ(ret, DumpStatus::DUMP_OK);
681 }
682 
683 /**
684  * @tc.name: JsHeapDumperTest002
685  * @tc.desc: Test JsHeapDumper with init pid and trigger gc.
686  * @tc.type: FUNC
687  */
688 HWTEST_F(HidumperDumpersTest, JsHeapDumperTest002, TestSize.Level1)
689 {
690     char *argv[] = {
691         const_cast<char *>("hidumper"),
692         const_cast<char *>("--mem-jsheap"),
693         const_cast<char *>("1"),
694         const_cast<char *>("--gc"),
695     };
696     int argc = sizeof(argv) / sizeof(argv[0]);
697     std::vector<std::u16string> args;
698     std::shared_ptr<RawParam> rawParam = std::make_shared<RawParam>(0, 1, 0, args, -1);
699     int ret = DumpImplement::GetInstance().Main(argc, argv, rawParam);
700     ASSERT_EQ(ret, DumpStatus::DUMP_OK);
701 }
702 
703 } // namespace HiviewDFX
704 } // namespace OHOS