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