1 /*
2 * Copyright (c) 2022-2024 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 <gtest/gtest.h>
16
17 #include "comm_log.h"
18 #include "securec.h"
19 #include "softbus_error_code.h"
20 #include "softbus_adapter_mem.h"
21 #include "softbus_common.h"
22 #include "legacy/softbus_hidumper_interface.h"
23 #include "legacy/softbus_hidumper.h"
24 #include "softbus_app_info.h"
25 #include "legacy/softbus_hidumper_alarm.h"
26 #include "legacy/softbus_hidumper_broadcast.h"
27 #include "legacy/softbus_hidumper_buscenter.h"
28 #include "legacy/softbus_hidumper_conn.h"
29 #include "legacy/softbus_hidumper_disc.h"
30 #include "legacy/softbus_hidumper_nstack.h"
31 #include "legacy/softbus_hidumper_stats.h"
32 #include "legacy/softbus_hidumper_trans.h"
33 #include "legacy/softbus_hidumper_util.h"
34
35 using namespace std;
36 using namespace testing::ext;
37
38 #define HIDUMPER_VAR_CASE_NUM 3
39 #define HIDUMPER_ARGV_NUM 10
40 #define TRANS_DUMP_PROCESS_TEST_NUM 4
41 #define DISC_DUMP_PROCESS_VALID_TEST_NUM 7
42 #define DISC_DUMP_PROCESS_INVALID_TEST_NUM 7
43 #define CONN_DUMP_PROCESS_VALID_TEST_NUM 6
44 #define CONN_DUMP_PROCESS_INVALID_TEST_NUM 5
45 #define BUSCENTER_DUMP_PROCESS_VALID_TEST_NUM 6
46 #define BUSCENTER_DUMP_PROCESS_INVALID_TEST_NUM 5
47 #define NSTACK_DUMP_PROCESS_VALID_TEST_NUM 4
48 #define STATS_DUMP_PROCESS_VALID_TEST_NUM 2
49 #define STATS_DUMP_PROCESS_INVALID_TEST_NUM 4
50 #define ALARM_DUMP_PROCESS_VALID_TEST_NUM 2
51 #define ALARM_DUMP_PROCESS_INVALID_TEST_NUM 4
52 #define TEST_UID 101
53 #define TEST_PID 202
54 #define ERR_FD (-1)
55 #define TEST_FD_ZERO 0
56 #define TEST_FD_ONE 1
57 #define ERR_ARGC (-1)
58 #define TEST_ARGC_ONE 1
59 #define TEST_ARGC_TWO 2
60 #define TEST_ARGC_THREE 3
61
62 static const char *g_testModuleName = "testModuleName";
63 static const char *g_testDumpVar = "test1";
64 static const char *g_testHelpInfo = "help";
65 namespace OHOS {
66 class HidumperTest : public testing::Test {
67 public:
68 static void SetUpTestCase();
69 static void TearDownTestCase();
70 void SetUp();
71 void TearDown();
72 };
73
SetUpTestCase(void)74 void HidumperTest::SetUpTestCase(void) {}
75
TearDownTestCase(void)76 void HidumperTest::TearDownTestCase(void) {}
77
SetUp(void)78 void HidumperTest::SetUp(void) {}
79
TearDown(void)80 void HidumperTest::TearDown(void) {}
81
82 typedef struct {
83 char varName[SOFTBUS_MODULE_NAME_LEN];
84 SoftBusVarDumpCb dumpCallback;
85 } HiDumperVarNode;
86
87 typedef struct {
88 int32_t fd;
89 int32_t argc;
90 const char* argv[HIDUMPER_ARGV_NUM];
91 } HiDumperArgvNode;
92
93 /**
94 * @tc.name: SoftBusHiDumperInitTest001
95 * @tc.desc: Verify SoftBusHiDumperInit function, no parameter.
96 * @tc.type: FUNC
97 * @tc.require:
98 */
99 HWTEST_F(HidumperTest, SoftBusHiDumperInitTest001, TestSize.Level1)
100 {
101 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusHiDumperInitTest001, Start");
102 int32_t ret = SoftBusHiDumperInit();
103 EXPECT_TRUE(ret == 0);
104 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusHiDumperInitTest001, end");
105 }
106
107 // -------------------------------------------broadcast------------------------------------------ //
BroadcastVarTest1Dumper(int32_t fd)108 static int32_t BroadcastVarTest1Dumper(int32_t fd)
109 {
110 COMM_LOGI(COMM_TEST, "BroadcastVarTest1Dumper called, fd=%{public}d", fd);
111 return SOFTBUS_OK;
112 }
113
BroadcastVarTest2Dumper(int32_t fd)114 static int32_t BroadcastVarTest2Dumper(int32_t fd)
115 {
116 COMM_LOGI(COMM_TEST, "BroadcastVarTest2Dumper called, fd=%{public}d", fd);
117 return SOFTBUS_OK;
118 }
119
BroadcastVarTest3Dumper(int32_t fd)120 static int32_t BroadcastVarTest3Dumper(int32_t fd)
121 {
122 COMM_LOGI(COMM_TEST, "BroadcastVarTest3Dumper called, fd=%{public}d", fd);
123 return SOFTBUS_OK;
124 }
125
126 /**
127 * @tc.name: SoftBusRegBroadcastVarDump001
128 * @tc.desc: Verify SoftBusRegBroadcastVarDump function, use broadcastVarArray param, return SOFTBUS_OK.
129 * @tc.type: FUNC
130 * @tc.require:
131 */
132 HWTEST_F(HidumperTest, SoftBusRegBroadcastVarDump001, TestSize.Level1)
133 {
134 HiDumperVarNode testBroadcastVarArray[HIDUMPER_VAR_CASE_NUM] = {
135 {"broadcast_var_test_1", &BroadcastVarTest1Dumper},
136 {"broadcast_var_test_2", &BroadcastVarTest2Dumper},
137 {"broadcast_var_test_3", &BroadcastVarTest3Dumper},
138 };
139 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegBroadcastVarDump001, Start");
140 int32_t ret;
141 for (int32_t i = 0; i < HIDUMPER_VAR_CASE_NUM; i++) {
142 ret = SoftBusRegBroadcastVarDump(testBroadcastVarArray[i].varName, testBroadcastVarArray[i].dumpCallback);
143 EXPECT_EQ(SOFTBUS_OK, ret);
144 }
145 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegBroadcastVarDump001, end");
146 }
147
148 /**
149 * @tc.name: SoftBusRegBroadcastVarDump002
150 * @tc.desc: Verify SoftBusRegBroadcastVarDump function, first param dumpVar is nullptr, return SOFTBUS_INVALID_PARAM.
151 * @tc.type: FUNC
152 * @tc.require:
153 */
154 HWTEST_F(HidumperTest, SoftBusRegBroadcastVarDump002, TestSize.Level1)
155 {
156 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegBroadcastVarDump002, Start");
157 int32_t ret = SoftBusRegBroadcastVarDump(nullptr, &BroadcastVarTest1Dumper);
158 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
159 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegBroadcastVarDump002, end");
160 }
161
162 /**
163 * @tc.name: SoftBusRegBroadcastVarDump003
164 * @tc.desc: Verify SoftBusRegBroadcastVarDump function, second param cb is nullptr, return SOFTBUS_INVALID_PARAM.
165 * @tc.type: FUNC
166 * @tc.require:
167 */
168 HWTEST_F(HidumperTest, SoftBusRegBroadcastVarDump003, TestSize.Level1)
169 {
170 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegBroadcastVarDump003, Start");
171 int32_t ret = SoftBusRegBroadcastVarDump(const_cast<char *>(g_testDumpVar), nullptr);
172 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
173 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegBroadcastVarDump003, end");
174 }
175
176 /**
177 * @tc.name: SoftBusRegBroadcastVarDump004
178 * @tc.desc: Verify SoftBusRegBroadcastVarDump function, first param dumpVar is nullptr,
179 * second cb is nullptr return SOFTBUS_INVALID_PARAM.
180 * @tc.type: FUNC
181 * @tc.require:
182 */
183 HWTEST_F(HidumperTest, SoftBusRegBroadcastVarDump004, TestSize.Level1)
184 {
185 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegBroadcastVarDump004, Start");
186 int32_t ret = SoftBusRegBroadcastVarDump(nullptr, nullptr);
187 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
188 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegBroadcastVarDump004, end");
189 }
190
191 // -------------------------------------------------disc----------------------------------------- //
DiscVarTest1Dumper(int32_t fd)192 static int32_t DiscVarTest1Dumper(int32_t fd)
193 {
194 COMM_LOGI(COMM_TEST, "DiscVarTest1Dumper called, fd=%{public}d", fd);
195 return SOFTBUS_OK;
196 }
197
DiscVarTest2Dumper(int32_t fd)198 static int32_t DiscVarTest2Dumper(int32_t fd)
199 {
200 COMM_LOGI(COMM_TEST, "DiscVarTest2Dumper called, fd=%{public}d", fd);
201 return SOFTBUS_OK;
202 }
203
DiscVarTest3Dumper(int32_t fd)204 static int32_t DiscVarTest3Dumper(int32_t fd)
205 {
206 COMM_LOGI(COMM_TEST, "DiscVarTest3Dumper called, fd=%{public}d", fd);
207 return SOFTBUS_OK;
208 }
209
210 /**
211 * @tc.name: SoftBusRegDiscVarDump001
212 * @tc.desc: Verify SoftBusRegDiscVarDump function, use discVarArray param, return SOFTBUS_OK.
213 * @tc.type: FUNC
214 * @tc.require:
215 */
216 HWTEST_F(HidumperTest, SoftBusRegDiscVarDump001, TestSize.Level1)
217 {
218 HiDumperVarNode testDiscVarArray[HIDUMPER_VAR_CASE_NUM] = {
219 {"disc_var_test_1", &DiscVarTest1Dumper},
220 {"disc_var_test_2", &DiscVarTest2Dumper},
221 {"disc_var_test_3", &DiscVarTest3Dumper},
222 };
223 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegDiscVarDump001, Start");
224 int32_t ret;
225 for (int32_t i = 0; i < HIDUMPER_VAR_CASE_NUM; i++) {
226 ret = SoftBusRegDiscVarDump(testDiscVarArray[i].varName, testDiscVarArray[i].dumpCallback);
227 EXPECT_EQ(SOFTBUS_OK, ret);
228 }
229 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegDiscVarDump001, end");
230 }
231
232 /**
233 * @tc.name: SoftBusRegDiscVarDump002
234 * @tc.desc: Verify SoftBusRegDiscVarDump function, first param dumpVar is nullptr, return SOFTBUS_ERR.
235 * @tc.type: FUNC
236 * @tc.require:
237 */
238 HWTEST_F(HidumperTest, SoftBusRegDiscVarDump002, TestSize.Level1)
239 {
240 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegDiscVarDump002, Start");
241 int32_t ret = SoftBusRegDiscVarDump(nullptr, &DiscVarTest1Dumper);
242 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
243 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegDiscVarDump002, end");
244 }
245
246 /**
247 * @tc.name: SoftBusRegDiscVarDump003
248 * @tc.desc: Verify SoftBusRegDiscVarDump function, second param cb is nullptr, return SOFTBUS_ERR.
249 * @tc.type: FUNC
250 * @tc.require:
251 */
252 HWTEST_F(HidumperTest, SoftBusRegDiscVarDump003, TestSize.Level1)
253 {
254 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegDiscVarDump003, Start");
255 int32_t ret = SoftBusRegDiscVarDump(const_cast<char *>(g_testDumpVar), nullptr);
256 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
257 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegDiscVarDump003, end");
258 }
259
260 /**
261 * @tc.name: SoftBusRegDiscVarDump004
262 * @tc.desc: Verify SoftBusRegDiscVarDump function, first param dumpVar is nullptr,
263 * second cb is nullptr return SOFTBUS_ERR.
264 * @tc.type: FUNC
265 * @tc.require:
266 */
267 HWTEST_F(HidumperTest, SoftBusRegDiscVarDump004, TestSize.Level1)
268 {
269 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegDiscVarDump004, Start");
270 int32_t ret = SoftBusRegDiscVarDump(nullptr, nullptr);
271 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
272 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegDiscVarDump004, end");
273 }
274
275 // -------------------------------------------------conn-----------------------------------------//
ConnVarTest1Dumper(int32_t fd)276 static int32_t ConnVarTest1Dumper(int32_t fd)
277 {
278 COMM_LOGI(COMM_TEST, "ConnVarTest1Dumper called, fd=%{public}d", fd);
279 return SOFTBUS_OK;
280 }
281
ConnVarTest2Dumper(int32_t fd)282 static int32_t ConnVarTest2Dumper(int32_t fd)
283 {
284 COMM_LOGI(COMM_TEST, "ConnVarTest2Dumper called, fd=%{public}d", fd);
285 return SOFTBUS_OK;
286 }
287
ConnVarTest3Dumper(int32_t fd)288 static int32_t ConnVarTest3Dumper(int32_t fd)
289 {
290 COMM_LOGI(COMM_TEST, "ConnVarTest3Dumper called, fd=%{public}d", fd);
291 return SOFTBUS_OK;
292 }
293
294 /**
295 * @tc.name: SoftBusRegConnVarDump001
296 * @tc.desc: Verify SoftBusRegConnVarDump function, use connVarArray param, return SOFTBUS_OK.
297 * @tc.type: FUNC
298 * @tc.require:
299 */
300 HWTEST_F(HidumperTest, SoftBusRegConnVarDump001, TestSize.Level1)
301 {
302 HiDumperVarNode testConnVarArray[HIDUMPER_VAR_CASE_NUM] = {
303 {"conn_var_test_1", &ConnVarTest1Dumper},
304 {"conn_var_test_2", &ConnVarTest2Dumper},
305 {"conn_var_test_3", &ConnVarTest3Dumper},
306 };
307 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegConnVarDump001, Start");
308 int32_t ret;
309 for (int32_t i = 0; i < HIDUMPER_VAR_CASE_NUM; i++) {
310 ret = SoftBusRegConnVarDump(testConnVarArray[i].varName, testConnVarArray[i].dumpCallback);
311 EXPECT_EQ(SOFTBUS_OK, ret);
312 }
313 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegConnVarDump001, end");
314 }
315
316 /**
317 * @tc.name: SoftBusRegConnVarDump002
318 * @tc.desc: Verify SoftBusRegConnVarDump function, first param dumpVar is nullptr, return SOFTBUS_ERR.
319 * @tc.type: FUNC
320 * @tc.require:
321 */
322 HWTEST_F(HidumperTest, SoftBusRegConnVarDump002, TestSize.Level1)
323 {
324 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegConnVarDump002, Start");
325 int32_t ret = SoftBusRegConnVarDump(nullptr, &ConnVarTest1Dumper);
326 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
327 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegConnVarDump002, end");
328 }
329
330 /**
331 * @tc.name: SoftBusRegConnVarDump003
332 * @tc.desc: Verify SoftBusRegConnVarDump function, second param cb is nullptr, return SOFTBUS_ERR.
333 * @tc.type: FUNC
334 * @tc.require:
335 */
336 HWTEST_F(HidumperTest, SoftBusRegConnVarDump003, TestSize.Level1)
337 {
338 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegConnVarDump003, Start");
339 int32_t ret = SoftBusRegConnVarDump(const_cast<char *>(g_testDumpVar), nullptr);
340 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
341 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegConnVarDump003, end");
342 }
343
344 /**
345 * @tc.name: SoftBusRegConnVarDump004
346 * @tc.desc: Verify SoftBusRegConnVarDump004 function, first param dumpVar is nullptr,
347 * second cb is nullptr return SOFTBUS_ERR.
348 * @tc.type: FUNC
349 * @tc.require:
350 */
351 HWTEST_F(HidumperTest, SoftBusRegConnVarDump004, TestSize.Level1)
352 {
353 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegConnVarDump004, Start");
354 int32_t ret = SoftBusRegConnVarDump(nullptr, nullptr);
355 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
356 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegConnVarDump004, end");
357 }
358
359 // -------------------------------------------------buscenter-----------------------------------------//
LnnVarTest1Dumper(int32_t fd)360 static int32_t LnnVarTest1Dumper(int32_t fd)
361 {
362 COMM_LOGI(COMM_TEST, "LnnVarTest1Dumper called, fd=%{public}d", fd);
363 return SOFTBUS_OK;
364 }
365
LnnVarTest2Dumper(int32_t fd)366 static int32_t LnnVarTest2Dumper(int32_t fd)
367 {
368 COMM_LOGI(COMM_TEST, "LnnVarTest2Dumper called, fd=%{public}d", fd);
369 return SOFTBUS_OK;
370 }
371
LnnVarTest3Dumper(int32_t fd)372 static int32_t LnnVarTest3Dumper(int32_t fd)
373 {
374 COMM_LOGI(COMM_TEST, "LnnVarTest3Dumper called, fd=%{public}d", fd);
375 return SOFTBUS_OK;
376 }
377
378 /**
379 * @tc.name: SoftBusRegBusCenterVarDump001
380 * @tc.desc: Verify SoftBusRegBusCenterVarDump function, use lnnVarArray param, return SOFTBUS_OK.
381 * @tc.type: FUNC
382 * @tc.require:
383 */
384 HWTEST_F(HidumperTest, SoftBusRegBusCenterVarDump001, TestSize.Level1)
385 {
386 HiDumperVarNode testLnnVarArray[HIDUMPER_VAR_CASE_NUM] = {
387 {"lnn_var_test_1", &LnnVarTest1Dumper},
388 {"lnn_var_test_2", &LnnVarTest2Dumper},
389 {"lnn_var_test_3", &LnnVarTest3Dumper},
390 };
391 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegDiscVarDump001, Start");
392 int32_t ret;
393 for (int32_t i = 0; i < HIDUMPER_VAR_CASE_NUM; i++) {
394 ret = SoftBusRegBusCenterVarDump(testLnnVarArray[i].varName, testLnnVarArray[i].dumpCallback);
395 EXPECT_EQ(SOFTBUS_OK, ret);
396 }
397 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegDiscVarDump001, end");
398 }
399
400 /**
401 * @tc.name: SoftBusRegBusCenterVarDump002
402 * @tc.desc: Verify SoftBusRegBusCenterVarDump function, first param dumpVar is nullptr, return SOFTBUS_ERR.
403 * @tc.type: FUNC
404 * @tc.require:
405 */
406 HWTEST_F(HidumperTest, SoftBusRegBusCenterVarDump002, TestSize.Level1)
407 {
408 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegBusCenterVarDump002, Start");
409 int32_t ret = SoftBusRegBusCenterVarDump(nullptr, &DiscVarTest1Dumper);
410 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
411 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegBusCenterVarDump002, end");
412 }
413
414 /**
415 * @tc.name: SoftBusRegBusCenterVarDump003
416 * @tc.desc: Verify SoftBusRegBusCenterVarDump function, second param cb is nullptr, return SOFTBUS_ERR.
417 * @tc.type: FUNC
418 * @tc.require:
419 */
420 HWTEST_F(HidumperTest, SoftBusRegBusCenterVarDump003, TestSize.Level1)
421 {
422 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegBusCenterVarDump003, Start");
423 int32_t ret = SoftBusRegBusCenterVarDump(const_cast<char *>(g_testDumpVar), nullptr);
424 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
425 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegBusCenterVarDump003, end");
426 }
427
428 /**
429 * @tc.name: SoftBusRegBusCenterVarDump004
430 * @tc.desc: Verify SoftBusRegBusCenterVarDump function, first param dumpVar is nullptr,
431 * second cb is nullptr return SOFTBUS_ERR.
432 * @tc.type: FUNC
433 * @tc.require:
434 */
435 HWTEST_F(HidumperTest, SoftBusRegBusCenterVarDump004, TestSize.Level1)
436 {
437 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegBusCenterVarDump004, Start");
438 int32_t ret = SoftBusRegBusCenterVarDump(nullptr, nullptr);
439 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
440 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegBusCenterVarDump004, end");
441 }
442
443 // --------------------------------------------trans------------------------------------------------- //
444 HiDumperArgvNode g_validTransCmdArray[TRANS_DUMP_PROCESS_TEST_NUM] = {
445 {TEST_FD_ZERO, TEST_ARGC_ONE, {"-h"}},
446 {TEST_FD_ZERO, TEST_ARGC_ONE, {"-l"}},
447 {TEST_FD_ZERO, TEST_ARGC_TWO, {"-l", "registed_sessionlist"}},
448 {TEST_FD_ZERO, TEST_ARGC_TWO, {"-l", "concurrent_sessionlist"}},
449 };
450
451 /**
452 * @tc.name: SoftBusDumpProcess001
453 * @tc.desc: Verify SoftBusDumpProcess function, valid param, use disc hidumper cmd, return SOFTBUS_OK
454 * @tc.type: FUNC
455 * @tc.require:
456 */
457 HWTEST_F(HidumperTest, SoftBusDumpProcess001, TestSize.Level1)
458 {
459 HiDumperArgvNode testValidDiscCmdArray[DISC_DUMP_PROCESS_VALID_TEST_NUM] = {
460 {TEST_FD_ZERO, TEST_ARGC_ONE, {"-h"}},
461 {TEST_FD_ZERO, TEST_ARGC_ONE, {"disc"}},
462 {TEST_FD_ZERO, TEST_ARGC_TWO, {"disc", "-h"}},
463 {TEST_FD_ZERO, TEST_ARGC_TWO, {"disc", "-l"}},
464 {TEST_FD_ZERO, TEST_ARGC_THREE, {"disc", "-l", "disc_var_test_1"}},
465 {TEST_FD_ZERO, TEST_ARGC_THREE, {"disc", "-l", "disc_var_test_2"}},
466 {TEST_FD_ZERO, TEST_ARGC_THREE, {"disc", "-l", "disc_var_test_3"}},
467 };
468 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess001, Start");
469 int32_t ret;
470 for (int32_t i = 0; i < DISC_DUMP_PROCESS_VALID_TEST_NUM; i++) {
471 ret = SoftBusDumpProcess(testValidDiscCmdArray[i].fd, testValidDiscCmdArray[i].argc,
472 testValidDiscCmdArray[i].argv);
473 EXPECT_EQ(SOFTBUS_OK, ret);
474 }
475 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess001, end");
476 }
477
478 /**
479 * @tc.name: SoftBusDumpProcess002
480 * @tc.desc: Verify SoftBusDumpProcess function, invalid param, use disc hidumper,return SOFTBUS_ERR
481 * @tc.type: FUNC
482 * @tc.require:
483 */
484 HWTEST_F(HidumperTest, SoftBusDumpProcess002, TestSize.Level1)
485 {
486 HiDumperArgvNode testInvalidDiscCmdArray[DISC_DUMP_PROCESS_VALID_TEST_NUM] = {
487 {ERR_FD, TEST_ARGC_ONE, {"-h"}},
488 {TEST_FD_ZERO, ERR_ARGC, {"disc"}},
489 {ERR_FD, ERR_ARGC, {"disc", "-h"}},
490 {ERR_FD, TEST_ARGC_TWO, {"disc", "-l"}},
491 {ERR_FD, TEST_ARGC_THREE, {"disc", "-l", "disc_var_test_1"}},
492 {ERR_FD, TEST_ARGC_ONE, {"disc", "-l", "disc_var_test_2"}},
493 {TEST_FD_ZERO, ERR_ARGC, {"disc", "-l", "disc_var_test_3"}},
494 };
495 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess002, Start");
496 int32_t ret;
497 for (int32_t i = 0; i < DISC_DUMP_PROCESS_VALID_TEST_NUM; i++) {
498 ret = SoftBusDumpProcess(testInvalidDiscCmdArray[i].fd, testInvalidDiscCmdArray[i].argc,
499 testInvalidDiscCmdArray[i].argv);
500 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
501 }
502 ret = SoftBusDumpProcess(0, 1, nullptr);
503 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
504 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess002, end");
505 }
506
507 /**
508 * @tc.name: SoftBusDumpProcess003
509 * @tc.desc: Verify SoftBusDumpProcess function, valid param, use buscenter hidumper cmd, return SOFTBUS_OK
510 * @tc.type: FUNC
511 * @tc.require:
512 */
513 HWTEST_F(HidumperTest, SoftBusDumpProcess003, TestSize.Level1)
514 {
515 HiDumperArgvNode testValidConnCmdArray[CONN_DUMP_PROCESS_VALID_TEST_NUM] = {
516 {TEST_FD_ZERO, TEST_ARGC_ONE, {"conn"}},
517 {TEST_FD_ZERO, TEST_ARGC_TWO, {"conn", "-h"}},
518 {TEST_FD_ZERO, TEST_ARGC_TWO, {"conn", "-l"}},
519 {TEST_FD_ZERO, TEST_ARGC_THREE, {"conn", "-l", "conn_var_test_1"}},
520 {TEST_FD_ZERO, TEST_ARGC_THREE, {"conn", "-l", "conn_var_test_2"}},
521 {TEST_FD_ZERO, TEST_ARGC_THREE, {"conn", "-l", "conn_var_test_3"}},
522 };
523 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess003, Start");
524 int32_t ret;
525 for (int32_t i = 0; i < CONN_DUMP_PROCESS_VALID_TEST_NUM; i++) {
526 ret = SoftBusDumpProcess(testValidConnCmdArray[i].fd, testValidConnCmdArray[i].argc,
527 testValidConnCmdArray[i].argv);
528 EXPECT_EQ(SOFTBUS_OK, ret);
529 }
530 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess003, end");
531 }
532
533 /**
534 * @tc.name: SoftBusDumpProcess004
535 * @tc.desc: Verify SoftBusDumpProcess function, invalid param, use conn hidumper,return SOFTBUS_ERR
536 * @tc.type: FUNC
537 * @tc.require:
538 */
539 HWTEST_F(HidumperTest, SoftBusDumpProcess004, TestSize.Level1)
540 {
541 HiDumperArgvNode testInValidConnCmdArray[CONN_DUMP_PROCESS_INVALID_TEST_NUM] = {
542 {ERR_FD, TEST_ARGC_ONE, {"-h"}},
543 {TEST_FD_ONE, ERR_ARGC, {"conn"}},
544 {ERR_FD, ERR_ARGC, {"conn", "-h"}},
545 {ERR_FD, TEST_ARGC_TWO, {"conn", "-l"}},
546 {ERR_FD, TEST_ARGC_THREE, {"conn", "-l", "conn_var_test_1"}},
547 };
548 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess004, Start");
549 int32_t ret;
550 for (int32_t i = 0; i < CONN_DUMP_PROCESS_INVALID_TEST_NUM; i++) {
551 ret = SoftBusDumpProcess(testInValidConnCmdArray[i].fd, testInValidConnCmdArray[i].argc,
552 testInValidConnCmdArray[i].argv);
553 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
554 }
555 ret = SoftBusDumpProcess(0, 1, nullptr);
556 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
557 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess004, end");
558 }
559
560 /**
561 * @tc.name: SoftBusDumpProcess005
562 * @tc.desc: Verify SoftBusDumpProcess function, valid param, use buscenter hidumper cmd, return SOFTBUS_OK
563 * @tc.type: FUNC
564 * @tc.require:
565 */
566 HWTEST_F(HidumperTest, SoftBusDumpProcess005, TestSize.Level1)
567 {
568 HiDumperArgvNode testValiBusCenterCmdArray[BUSCENTER_DUMP_PROCESS_VALID_TEST_NUM] = {
569 {TEST_FD_ZERO, TEST_ARGC_ONE, {"buscenter"}},
570 {TEST_FD_ZERO, TEST_ARGC_TWO, {"buscenter", "-h"}},
571 {TEST_FD_ZERO, TEST_ARGC_TWO, {"buscenter", "-l"}},
572 {TEST_FD_ZERO, TEST_ARGC_THREE, {"buscenter", "-l", "buscenter_var_test_1"}},
573 {TEST_FD_ZERO, TEST_ARGC_THREE, {"buscenter", "-l", "buscenter_var_test_2"}},
574 {TEST_FD_ZERO, TEST_ARGC_THREE, {"buscenter", "-l", "buscenter_var_test_3"}},
575 };
576 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess005, Start");
577 int32_t ret;
578 for (int32_t i = 0; i < BUSCENTER_DUMP_PROCESS_VALID_TEST_NUM; i++) {
579 ret = SoftBusDumpProcess(testValiBusCenterCmdArray[i].fd, testValiBusCenterCmdArray[i].argc,
580 testValiBusCenterCmdArray[i].argv);
581 EXPECT_EQ(SOFTBUS_OK, ret);
582 }
583 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess005, end");
584 }
585
586 /**
587 * @tc.name: SoftBusDumpProcess006
588 * @tc.desc: Verify SoftBusDumpProcess function, invalid param, use buscenter hidumper,return SOFTBUS_ERR
589 * @tc.type: FUNC
590 * @tc.require:
591 */
592 HWTEST_F(HidumperTest, SoftBusDumpProcess006, TestSize.Level1)
593 {
594 HiDumperArgvNode testInValidBusCenterCmdArray[BUSCENTER_DUMP_PROCESS_INVALID_TEST_NUM] = {
595 {ERR_FD, TEST_ARGC_ONE, {"-h"}},
596 {TEST_FD_ZERO, ERR_ARGC, {"buscenter"}},
597 {ERR_FD, ERR_ARGC, {"buscenter", "-h"}},
598 {ERR_FD, TEST_ARGC_TWO, {"buscenter", "-l"}},
599 {ERR_FD, TEST_ARGC_THREE, {"buscenter", "-l", "buscenter_var_test_1"}},
600 };
601 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess006, Start");
602 int32_t ret;
603 for (int32_t i = 0; i < BUSCENTER_DUMP_PROCESS_INVALID_TEST_NUM; i++) {
604 ret = SoftBusDumpProcess(testInValidBusCenterCmdArray[i].fd, testInValidBusCenterCmdArray[i].argc,
605 testInValidBusCenterCmdArray[i].argv);
606 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
607 }
608 ret = SoftBusDumpProcess(0, 1, nullptr);
609 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
610 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess006, end");
611 }
612
613 /**
614 * @tc.name: SoftBusDumpProcess007
615 * @tc.desc: Verify SoftBusDumpProcess function, valid param, use nstack hidumper cmd, return SOFTBUS_OK
616 * @tc.type: FUNC
617 * @tc.require:
618 */
619 HWTEST_F(HidumperTest, SoftBusDumpProcess007, TestSize.Level1)
620 {
621 HiDumperArgvNode testValidNstackCmdArray[NSTACK_DUMP_PROCESS_VALID_TEST_NUM] = {
622 {TEST_FD_ZERO, TEST_ARGC_ONE, {"dstream"}},
623 {TEST_FD_ZERO, TEST_ARGC_ONE, {"dmsg", }},
624 {TEST_FD_ZERO, TEST_ARGC_ONE, {"dfile"}},
625 {TEST_FD_ZERO, TEST_ARGC_ONE, {"dmsg"}},
626 };
627 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess007, Start");
628 int32_t ret;
629 for (int32_t i = 0; i < NSTACK_DUMP_PROCESS_VALID_TEST_NUM; i++) {
630 ret = SoftBusDumpProcess(testValidNstackCmdArray[i].fd, testValidNstackCmdArray[i].argc,
631 testValidNstackCmdArray[i].argv);
632 EXPECT_EQ(SOFTBUS_OK, ret);
633 }
634 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess007, end");
635 }
636
637 /**
638 * @tc.name: SoftBusDumpProcess008
639 * @tc.desc: Verify SoftBusDumpProcess function, valid param, use stats hidumper cmd, return SOFTBUS_OK
640 * @tc.type: FUNC
641 * @tc.require:
642 */
643 HWTEST_F(HidumperTest, SoftBusDumpProcess008, TestSize.Level1)
644 {
645 HiDumperArgvNode testValidStatsCmdArray[STATS_DUMP_PROCESS_VALID_TEST_NUM] = {
646 {TEST_FD_ZERO, TEST_ARGC_TWO, {"stats", "15min"}},
647 {TEST_FD_ZERO, TEST_ARGC_TWO, {"stats", "24h"}},
648 };
649 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess008, Start");
650 int32_t ret;
651 for (int32_t i = 0; i < STATS_DUMP_PROCESS_VALID_TEST_NUM; i++) {
652 ret = SoftBusDumpProcess(testValidStatsCmdArray[i].fd, testValidStatsCmdArray[i].argc,
653 testValidStatsCmdArray[i].argv);
654 EXPECT_EQ(SOFTBUS_OK, ret);
655 }
656 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess008, end");
657 }
658
659 /**
660 * @tc.name: SoftBusDumpProcess009
661 * @tc.desc: Verify SoftBusDumpProcess function, invalid param, use stats hidumper cmd, return SOFTBUS_ERR
662 * @tc.type: FUNC
663 * @tc.require:
664 */
665 HWTEST_F(HidumperTest, SoftBusDumpProcess009, TestSize.Level1)
666 {
667 HiDumperArgvNode testInValidStatsCmdArray[STATS_DUMP_PROCESS_INVALID_TEST_NUM] = {
668 {ERR_FD, TEST_ARGC_ONE, {"-h"}},
669 {TEST_FD_ZERO, ERR_ARGC, {"stats"}},
670 {ERR_FD, ERR_ARGC, {"stats", "-l"}},
671 {ERR_FD, TEST_ARGC_THREE, {"stats", "-l", "stats_var_test_1"}},
672 };
673 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess009, Start");
674 int32_t ret;
675 for (int32_t i = 0; i < NSTACK_DUMP_PROCESS_VALID_TEST_NUM; i++) {
676 ret = SoftBusDumpProcess(testInValidStatsCmdArray[i].fd, testInValidStatsCmdArray[i].argc,
677 testInValidStatsCmdArray[i].argv);
678 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
679 }
680 ret = SoftBusDumpProcess(0, 1, nullptr);
681 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
682 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess009, end");
683 }
684
685 /**
686 * @tc.name: SoftBusDumpProcess010
687 * @tc.desc: Verify SoftBusDumpProcess function, valid param, use alarm hidumper cmd, return SOFTBUS_OK
688 * @tc.type: FUNC
689 * @tc.require:
690 */
691 HWTEST_F(HidumperTest, SoftBusDumpProcess010, TestSize.Level1)
692 {
693 HiDumperArgvNode testValidAlarmCmdArray[ALARM_DUMP_PROCESS_VALID_TEST_NUM] = {
694 {TEST_FD_ZERO, TEST_ARGC_TWO, {"alert", "control"}},
695 {TEST_FD_ZERO, TEST_ARGC_TWO, {"alert", "management"}},
696 };
697 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess010, Start");
698 int32_t ret;
699 for (int32_t i = 0; i < ALARM_DUMP_PROCESS_VALID_TEST_NUM; i++) {
700 ret = SoftBusDumpProcess(testValidAlarmCmdArray[i].fd, testValidAlarmCmdArray[i].argc,
701 testValidAlarmCmdArray[i].argv);
702 EXPECT_EQ(SOFTBUS_OK, ret);
703 }
704 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess010, end");
705 }
706
707 /**
708 * @tc.name: SoftBusDumpProcess011
709 * @tc.desc: Verify SoftBusDumpProcess function, invalid param, use alarm hidumper cmd, return SOFTBUS_OK
710 * @tc.type: FUNC
711 * @tc.require:
712 */
713 HWTEST_F(HidumperTest, SoftBusDumpProcess011, TestSize.Level1)
714 {
715 HiDumperArgvNode testInValidAlarmCmdArray[ALARM_DUMP_PROCESS_INVALID_TEST_NUM] = {
716 {ERR_FD, TEST_ARGC_ONE, {"-h"}},
717 {TEST_FD_ZERO, ERR_ARGC, {"alert"}},
718 {ERR_FD, ERR_ARGC, {"alert", "-l"}},
719 {ERR_FD, TEST_ARGC_THREE, {"alert", "-l", "alert_var_test_1"}},
720 };
721 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess011, Start");
722 int32_t ret;
723 for (int32_t i = 0; i < ALARM_DUMP_PROCESS_INVALID_TEST_NUM; i++) {
724 ret = SoftBusDumpProcess(testInValidAlarmCmdArray[i].fd, testInValidAlarmCmdArray[i].argc,
725 testInValidAlarmCmdArray[i].argv);
726 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
727 }
728 ret = SoftBusDumpProcess(0, 1, nullptr);
729 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
730 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusDumpProcess011, end");
731 }
732
DumpHandlerTest1(int32_t fd,int32_t argc,const char ** argv)733 int32_t DumpHandlerTest1(int32_t fd, int32_t argc, const char **argv)
734 {
735 COMM_LOGE(COMM_TEST, "DumpHandlerTest1:fd=%{public}d, argc=%{public}d", fd, argc);
736 return SOFTBUS_OK;
737 }
738 /**
739 * @tc.name: SoftBusRegHiDumperHandler001
740 * @tc.desc: Verify SoftBusRegHiDumperHandler function, invalid param, return SOFTBUS_ERR.
741 * test the void function using invalid param
742 * @tc.type: FUNC
743 * @tc.require:
744 */
745 HWTEST_F(HidumperTest, SoftBusRegHiDumperHandler001, TestSize.Level1)
746 {
747 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegHiDumperHandler001, Start");
748 int32_t ret = SoftBusRegHiDumperHandler(const_cast<char *>(g_testModuleName),
749 const_cast<char *>(g_testHelpInfo), DumpHandlerTest1);
750 EXPECT_EQ(SOFTBUS_OK, ret);
751 ret = SoftBusRegHiDumperHandler(nullptr, const_cast<char *>(g_testHelpInfo), DumpHandlerTest1);
752 EXPECT_EQ(SOFTBUS_ERR, ret);
753 ret = SoftBusRegHiDumperHandler(const_cast<char *>(g_testModuleName), const_cast<char *>(g_testHelpInfo), nullptr);
754 EXPECT_EQ(SOFTBUS_ERR, ret);
755 SoftBusDumpShowHelp(ERR_FD);
756 SoftBusDumpErrInfo(ERR_FD, g_testDumpVar);
757 SoftBusDumpSubModuleHelp(ERR_FD, const_cast<char *>(g_testModuleName), nullptr);
758 SoftBusAddDumpVarToList(nullptr, nullptr, nullptr);
759 SoftBusReleaseDumpVar(nullptr);
760 const char *testHandler = "testHandler";
761 const char **tmpTestHandle = &testHandler;
762
763 ret = SoftBusDumpDispatch(ERR_FD, TEST_ARGC_ONE, tmpTestHandle);
764 EXPECT_EQ(SOFTBUS_ERR, ret);
765 ret = SoftBusDumpDispatch(TEST_FD_ZERO, ERR_ARGC, tmpTestHandle);
766 EXPECT_EQ(SOFTBUS_ERR, ret);
767 ret = SoftBusDumpDispatch(TEST_FD_ZERO, TEST_ARGC_ONE, nullptr);
768 EXPECT_EQ(SOFTBUS_ERR, ret);
769 COMM_LOGI(COMM_TEST, "HidumperTest, SoftBusRegHiDumperHandler001, end");
770 }
771 } // namespace OHOS