1 /*
2 * Copyright (c) 2022 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 "hilogtool_test.h"
16 #include "hilog/log_c.h"
17 #include <log_utils.h>
18 #include <properties.h>
19 #include <hilog_common.h>
20 #include <list>
21 #include <regex>
22
23 using namespace std;
24 using namespace testing::ext;
25 using namespace OHOS;
26 using namespace OHOS::HiviewDFX;
27
GetCmdLinesFromPopen(const std::string & cmd)28 static int GetCmdLinesFromPopen(const std::string& cmd)
29 {
30 if (cmd.empty()) {
31 return 0;
32 }
33 FILE* fp = popen(cmd.c_str(), "r");
34 if (fp == nullptr) {
35 return 0;
36 }
37 int ret = 0;
38 char* buffer = nullptr;
39 size_t len = 0;
40 while (getline(&buffer, &len, fp) != -1) {
41 ret++;
42 }
43 if (buffer != nullptr) {
44 free(buffer);
45 buffer = nullptr;
46 }
47 pclose(fp);
48 return ret;
49 }
50
GetCmdResultFromPopen(const std::string & cmd)51 static std::string GetCmdResultFromPopen(const std::string& cmd)
52 {
53 if (cmd.empty()) {
54 return "";
55 }
56 FILE* fp = popen(cmd.c_str(), "r");
57 if (fp == nullptr) {
58 return "";
59 }
60 std::string ret = "";
61 char* buffer = nullptr;
62 size_t len = 0;
63 while (getline(&buffer, &len, fp) != -1) {
64 std::string line = buffer;
65 ret += line;
66 }
67 if (buffer != nullptr) {
68 free(buffer);
69 buffer = nullptr;
70 }
71 pclose(fp);
72 return ret;
73 }
74
IsExistInCmdResult(const std::string & cmd,const std::string & str)75 static bool IsExistInCmdResult(const std::string &cmd, const std::string &str)
76 {
77 if (cmd.empty()) {
78 return false;
79 }
80 FILE* fp = popen(cmd.c_str(), "r");
81 if (fp == nullptr) {
82 return false;
83 }
84 bool ret = false;
85 char* buffer = nullptr;
86 size_t len = 0;
87 while (getline(&buffer, &len, fp) != -1) {
88 std::string line = buffer;
89 if (line.find(str) != string::npos) {
90 ret = true;
91 break;
92 }
93 }
94 if (buffer != nullptr) {
95 free(buffer);
96 buffer = nullptr;
97 }
98 pclose(fp);
99 return ret;
100 }
101
TearDownTestCase()102 void HilogToolTest::TearDownTestCase()
103 {
104 (void)GetCmdResultFromPopen("hilog -b I");
105 (void)GetCmdResultFromPopen("hilog -G 256K");
106 (void)GetCmdResultFromPopen("hilog -w stop");
107 (void)GetCmdResultFromPopen("hilog -w start");
108 }
109
110 namespace {
111 const std::list<pair<string, string>> helperList = {
112 /* help cmd suffix, information key word */
113 {"", "Usage"},
114 {"query", "Query"},
115 {"clear", "Remove"},
116 {"buffer", "buffer"},
117 {"stats", "statistics"},
118 {"persist", "persistance"},
119 {"private", "privacy"},
120 {"kmsg", "kmsg"},
121 {"flowcontrol", "flow-control"},
122 {"baselevel", "baselevel"},
123 {"combo", "combination"},
124 {"domain", "domain"},
125 };
126
127 /**
128 * @tc.name: Dfx_HilogToolTest_HelperTest_001
129 * @tc.desc: hilog help information.
130 * @tc.type: FUNC
131 */
132 HWTEST_F(HilogToolTest, HelperTest_001, TestSize.Level1)
133 {
134 /**
135 * @tc.steps: step1. show hilog help information.
136 * @tc.steps: step2. invalid cmd.
137 */
138 GTEST_LOG_(INFO) << "HelperTest_001: start.";
139 std::string prefix = "hilog -h ";
140 std::string cmd = "";
141 for (auto &it : helperList) {
142 cmd = prefix + it.first;
143 EXPECT_TRUE(IsExistInCmdResult(cmd, it.second));
144 }
145
146 prefix = "hilog --help ";
147 for (auto &it : helperList) {
148 cmd = prefix + it.first;
149 EXPECT_TRUE(IsExistInCmdResult(cmd, it.second));
150 }
151 }
152
153 /**
154 * @tc.name: Dfx_HilogToolTest_HandleTest_001
155 * @tc.desc: BaseLogLevelHandler.
156 * @tc.type: FUNC
157 */
158 HWTEST_F(HilogToolTest, HandleTest_001, TestSize.Level1)
159 {
160 /**
161 * @tc.steps: step1. set global log level to INFO.
162 * @tc.steps: step2. invalid log level.
163 */
164 GTEST_LOG_(INFO) << "HandleTest_001: start.";
165 std::string level = "I";
166 std::string cmd = "hilog -b " + level;
167 std::string str = "Set global log level to " + level + " successfully\n";
168 std::string query = "param get hilog.loggable.global";
169 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
170 EXPECT_EQ(GetCmdResultFromPopen(query), level + " \n");
171
172 // stderr redirect to stdout
173 cmd = "hilog -b test_level 2>&1";
174 std::string errMsg = ErrorCode2Str(ERR_LOG_LEVEL_INVALID) + "\n";
175 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
176 }
177
178 /**
179 * @tc.name: Dfx_HilogToolTest_HandleTest_002
180 * @tc.desc: DomainHandler.
181 * @tc.type: FUNC
182 */
183 HWTEST_F(HilogToolTest, HandleTest_002, TestSize.Level1)
184 {
185 /**
186 * @tc.steps: step1. set domain xxx log level to INFO.
187 * @tc.steps: step2. invaild domain.
188 */
189 GTEST_LOG_(INFO) << "HandleTest_002: start.";
190 uint32_t domain = 0xd002d00;
191 std::string level = "I";
192 std::string cmd = "hilog -b " + level + " -D " + Uint2HexStr(domain);
193 std::string str = "Set domain 0x" + Uint2HexStr(domain) + " log level to " + level + " successfully\n";
194 std::string query = "param get hilog.loggable.domain." + Uint2HexStr(domain);
195 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
196 EXPECT_EQ(GetCmdResultFromPopen(query), level + " \n");
197
198 cmd = "hilog -D test_domain 2>&1";
199 std::string errMsg = ErrorCode2Str(ERR_INVALID_DOMAIN_STR) + "\n";
200 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
201 }
202
203 /**
204 * @tc.name: Dfx_HilogToolTest_HandleTest_003
205 * @tc.desc: TagHandler.
206 * @tc.type: FUNC
207 */
208 HWTEST_F(HilogToolTest, HandleTest_003, TestSize.Level1)
209 {
210 /**
211 * @tc.steps: step1. set tag xxx log level to INFO.
212 * @tc.steps: step2. invalid tag.
213 */
214 GTEST_LOG_(INFO) << "HandleTest_003: start.";
215 std::string tag = "test";
216 std::string level = "I";
217 std::string cmd = "hilog -b " + level + " -T " + tag;
218 std::string str = "Set tag " + tag + " log level to " + level + " successfully\n";
219 std::string query = "param get hilog.loggable.tag." + tag;
220 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
221 EXPECT_EQ(GetCmdResultFromPopen(query), level + " \n");
222
223 cmd = "hilog -T abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 2>&1";
224 std::string errMsg = ErrorCode2Str(ERR_TAG_STR_TOO_LONG) + "\n";
225 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
226 }
227
228 /**
229 * @tc.name: Dfx_HilogToolTest_HandleTest_004
230 * @tc.desc: BufferSizeSetHandler.
231 * @tc.type: FUNC
232 */
233 HWTEST_F(HilogToolTest, HandleTest_004, TestSize.Level1)
234 {
235 /**
236 * @tc.steps: step1. set app,init.core buffer size [valid].
237 * @tc.expected: step1. set app,init.core buffer size successfully.
238 * @tc.steps: step2. set app,init.core buffer size [invalid].
239 * @tc.expected: step2 set app,init.core buffer size failed.
240 * buffer size should be in range [64.0K, 512.0M].
241 * @tc.expected: step3 invalid buffer size str.
242 */
243 GTEST_LOG_(INFO) << "HandleTest_004: start.";
244 std::string cmd = "hilog -G 512K";
245 std::string str = "Set log type app buffer size to 512.0K successfully\n"
246 "Set log type init buffer size to 512.0K successfully\n"
247 "Set log type core buffer size to 512.0K successfully\n";
248 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
249
250 cmd = "hilog -G 512G";
251 str = "failed";
252 EXPECT_TRUE(IsExistInCmdResult(cmd, str));
253
254 std::string inValidStrCmd = "hilog -G test_buffersize 2>&1";
255 std::string errMsg = ErrorCode2Str(ERR_INVALID_SIZE_STR) + "\n";
256 EXPECT_EQ(GetCmdResultFromPopen(inValidStrCmd), errMsg);
257 }
258
259 /**
260 * @tc.name: Dfx_HilogToolTest_HandleTest_005
261 * @tc.desc: BufferSizeGetHandler.
262 * @tc.type: FUNC
263 */
264 HWTEST_F(HilogToolTest, HandleTest_005, TestSize.Level1)
265 {
266 /**
267 * @tc.steps: step1. get app,init.core valid buffer size.
268 */
269 GTEST_LOG_(INFO) << "HandleTest_005: start.";
270 std::string cmd = "hilog -g";
271 std::string str = "Log type app buffer size is 512.0K\n"
272 "Log type init buffer size is 512.0K\n"
273 "Log type core buffer size is 512.0K\n";
274 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
275 }
276
277 /**
278 * @tc.name: Dfx_HilogToolTest_HandleTest_006
279 * @tc.desc: KmsgFeatureSetHandler.
280 * @tc.type: FUNC
281 */
282 HWTEST_F(HilogToolTest, HandleTest_006, TestSize.Level1)
283 {
284 /**
285 * @tc.steps: step1. set hilogd storing kmsg log feature on.
286 * @tc.steps: step2. set hilogd storing kmsg log feature off.
287 * @tc.steps: step3. set hilogd storing kmsg log feature invalid.
288 */
289 GTEST_LOG_(INFO) << "HandleTest_006: start.";
290 std::string cmd = "hilog -k on";
291 std::string str = "Set hilogd storing kmsg log on successfully\n";
292 std::string query = "param get persist.sys.hilog.kmsg.on";
293 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
294 EXPECT_EQ(GetCmdResultFromPopen(query), "true \n");
295
296 cmd = "hilog -k off";
297 str = "Set hilogd storing kmsg log off successfully\n";
298 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
299 EXPECT_EQ(GetCmdResultFromPopen(query), "false \n");
300
301 cmd = "hilog -k test_feature 2>&1";
302 std::string errMsg = ErrorCode2Str(ERR_INVALID_ARGUMENT) + "\n";
303 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
304 }
305
306 /**
307 * @tc.name: Dfx_HilogToolTest_HandleTest_007
308 * @tc.desc: PrivateFeatureSetHandler.
309 * @tc.type: FUNC
310 */
311 HWTEST_F(HilogToolTest, HandleTest_007, TestSize.Level1)
312 {
313 /**
314 * @tc.steps: step1. set hilog api privacy formatter feature on.
315 * @tc.steps: step2. set hilog api privacy formatter feature off.
316 * @tc.steps: step3. set hilog api privacy formatter feature invalid.
317 */
318 GTEST_LOG_(INFO) << "HandleTest_007: start.";
319 std::string cmd = "hilog -p on";
320 std::string str = "Set hilog privacy format on successfully\n";
321 std::string query = "param get hilog.private.on";
322 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
323 EXPECT_EQ(GetCmdResultFromPopen(query), "true \n");
324
325 cmd = "hilog -p off";
326 str = "Set hilog privacy format off successfully\n";
327 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
328 EXPECT_EQ(GetCmdResultFromPopen(query), "false \n");
329
330 cmd = "hilog -p test_feature 2>&1";
331 std::string errMsg = ErrorCode2Str(ERR_INVALID_ARGUMENT) + "\n";
332 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
333 }
334
335 /**
336 * @tc.name: Dfx_HilogToolTest_HandleTest_008
337 * @tc.desc: FlowControlFeatureSetHandler.
338 * @tc.type: FUNC
339 */
340 HWTEST_F(HilogToolTest, HandleTest_008, TestSize.Level1)
341 {
342 /**
343 * @tc.steps: step1. set process flow control on.
344 * @tc.steps: step2. set process flow control off.
345 * @tc.steps: step3. set domain flow control on.
346 * @tc.steps: step4. set domain flow control off.
347 * @tc.steps: step5. invalid cmd.
348 */
349 GTEST_LOG_(INFO) << "HandleTest_008: start.";
350 std::string cmd = "hilog -Q pidon";
351 std::string str = "Set flow control by process to enabled, result: Success [CODE: 0]\n";
352 std::string query = "param get hilog.flowctrl.proc.on";
353 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
354 EXPECT_EQ(GetCmdResultFromPopen(query), "true \n");
355
356 cmd = "hilog -Q pidoff";
357 str = "Set flow control by process to disabled, result: Success [CODE: 0]\n";
358 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
359 EXPECT_EQ(GetCmdResultFromPopen(query), "false \n");
360
361 cmd = "hilog -Q domainon";
362 str = "Set flow control by domain to enabled, result: Success [CODE: 0]\n";
363 query = "param get hilog.flowctrl.domain.on";
364 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
365 EXPECT_EQ(GetCmdResultFromPopen(query), "true \n");
366
367 cmd = "hilog -Q domainoff";
368 str = "Set flow control by domain to disabled, result: Success [CODE: 0]\n";
369 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
370 EXPECT_EQ(GetCmdResultFromPopen(query), "false \n");
371
372 cmd = "hilog -Q test_cmd 2>&1";
373 std::string errMsg = ErrorCode2Str(ERR_INVALID_ARGUMENT) + "\n";
374 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
375 }
376
377 /**
378 * @tc.name: Dfx_HilogToolTest_HandleTest_009
379 * @tc.desc: HeadHandler & TailHandler.
380 * @tc.type: FUNC
381 */
382 HWTEST_F(HilogToolTest, HandleTest_009, TestSize.Level1)
383 {
384 /**
385 * @tc.steps: step1. show n lines logs on head of buffer.
386 * @tc.steps: step2. show n lines logs on tail of buffer.
387 * @tc.steps: step3. invalid cmd.
388 */
389 GTEST_LOG_(INFO) << "HandleTest_009: start.";
390 int lines = 5;
391 std::string cmd = "hilog -a " + std::to_string(lines);
392 EXPECT_EQ(GetCmdLinesFromPopen(cmd), lines);
393
394 cmd = "hilog -z " + std::to_string(lines);
395 EXPECT_EQ(GetCmdLinesFromPopen(cmd), lines);
396
397 cmd = "hilog -a test 2>&1";
398 std::string errMsg = ErrorCode2Str(ERR_NOT_NUMBER_STR) + "\n";
399 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
400
401 cmd = "hilog -z test 2>&1";
402 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
403
404 cmd = "hilog -a 10 -z 10 2>&1";
405 errMsg = ErrorCode2Str(ERR_COMMAND_INVALID) + "\n";
406 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
407 }
408
409 /**
410 * @tc.name: Dfx_HilogToolTest_HandleTest_010
411 * @tc.desc: RemoveHandler.
412 * @tc.type: FUNC
413 */
414 HWTEST_F(HilogToolTest, HandleTest_010, TestSize.Level1)
415 {
416 /**
417 * @tc.steps: step1. get the localtime.
418 * @tc.steps: step2. remove all logs in hilogd buffer.
419 * @tc.steps: step3. compare the logtime to localtime.
420 */
421 GTEST_LOG_(INFO) << "HandleTest_010: start.";
422 time_t tnow = time(nullptr);
423 struct tm *tmNow = localtime(&tnow);
424 char clearTime[32] = {0};
425 if (tmNow != nullptr) {
426 strftime(clearTime, sizeof(clearTime), "%m-%d %H:%M:%S.%s", tmNow);
427 }
428 std::string cmd = "hilog -r";
429 std::string str = "Log type core,app buffer clear successfully\n";
430 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
431
432 sleep(1);
433 std::string res = GetCmdResultFromPopen("hilog -a 5");
434 std::string initStr = "HiLog: ========Zeroth log of type: init";
435 vector<string> vec;
436 std::string logTime = "";
437 Split(res, vec, "\n");
438 for (auto& it : vec) {
439 if (it.find(initStr) == string::npos) {
440 logTime = it.substr(0, 18);
441 EXPECT_LT(clearTime, logTime);
442 }
443 }
444 }
445
446 /**
447 * @tc.name: Dfx_HilogToolTest_HandleTest_011
448 * @tc.desc: TypeHandler.
449 * @tc.type: FUNC
450 */
451 HWTEST_F(HilogToolTest, HandleTest_011, TestSize.Level1)
452 {
453 /**
454 * @tc.steps: step1. remove app logs in hilogd buffer.
455 * @tc.steps: step2. remove core logs in hilogd buffer.
456 * @tc.steps: step3. invalid log type.
457 */
458 GTEST_LOG_(INFO) << "HandleTest_011: start.";
459 std::string cmd = "hilog -r -t app";
460 std::string str = "Log type app buffer clear successfully\n";
461 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
462
463 cmd = "hilog -r -t core";
464 str = "Log type core buffer clear successfully\n";
465 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
466
467 cmd = "hilog -r -t test_type 2>&1";
468 std::string errMsg = ErrorCode2Str(ERR_LOG_TYPE_INVALID) + "\n";
469 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
470 }
471
472 /**
473 * @tc.name: Dfx_HilogToolTest_HandleTest_012
474 * @tc.desc: PersistTaskHandler FileNameHandler JobIdHandler FileLengthHandler FileNumberHandler.
475 * @tc.type: FUNC
476 */
477 HWTEST_F(HilogToolTest, HandleTest_012, TestSize.Level1)
478 {
479 /**
480 * @tc.steps: step1. start hilog persistance task control.
481 * @tc.steps: step2. stop hilog persistance task control.
482 * @tc.steps: step3. start hilog persistance task control with advanced options.
483 * @tc.steps: step4. query tasks informations.
484 * @tc.steps: step5. invalid persistance cmd.
485 * @tc.steps: step6. query invalid filename.
486 * @tc.steps: step7. query invalid jobid.
487 * @tc.steps: step8. query invalid filelength.
488 * @tc.steps: step9. query invalid filenumber.
489 */
490 GTEST_LOG_(INFO) << "HandleTest_012: start.";
491 (void)GetCmdResultFromPopen("hilog -w stop");
492 std::string cmd = "hilog -w start";
493 std::string str = "Persist task [jobid:1] start successfully\n";
494 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
495
496 cmd = "hilog -w stop";
497 str = "Persist task [jobid:1] stop successfully\n";
498 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
499
500 std::string filename = "test";
501 uint64_t length = 2 * 1024 * 1024;
502 std::string unit = "B";
503 std::string compress = "zlib";
504 int num = 25;
505 int jobid = 200;
506 cmd = "hilog -w start -f " + filename + " -l " + std::to_string(length) + unit
507 + " -n " + std::to_string(num) + " -m " + compress + " -j " + std::to_string(jobid);
508 str = "Persist task [jobid:" + std::to_string(jobid) + "] start successfully\n";
509 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
510
511 cmd = "hilog -w query";
512 str = std::to_string(jobid) + " init,core,app " + compress + " /data/log/hilog/" + filename
513 + " " + Size2Str(length) + " " + std::to_string(num) + "\n";
514 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
515
516 cmd = "hilog -w test 2>&1";
517 std::string errMsg = ErrorCode2Str(ERR_INVALID_ARGUMENT) + "\n";
518 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
519
520 filename = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
521 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
522 cmd = "hilog -w query -f " + filename + " 2>&1";
523 errMsg = ErrorCode2Str(ERR_FILE_NAME_TOO_LONG) + "\n";
524 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
525
526 cmd = "hilog -w query -j test 2>&1";
527 errMsg = ErrorCode2Str(ERR_NOT_NUMBER_STR) + "\n";
528 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
529
530 cmd = "hilog -w query -l test 2>&1";
531 errMsg = ErrorCode2Str(ERR_INVALID_SIZE_STR) + "\n";
532 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
533
534 cmd = "hilog -w query -n test 2>&1";
535 errMsg = ErrorCode2Str(ERR_NOT_NUMBER_STR) + "\n";
536 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
537 }
538
539 /**
540 * @tc.name: Dfx_HilogToolTest_HandleTest_013
541 * @tc.desc: RegexHandler.
542 * @tc.type: FUNC
543 */
544 HWTEST_F(HilogToolTest, HandleTest_013, TestSize.Level1)
545 {
546 /**
547 * @tc.steps: step1. show the logs which match the regular expression.
548 * @tc.steps: step2. invaild regex.
549 */
550 GTEST_LOG_(INFO) << "HandleTest_013: start.";
551 std::string cmd = "hilog -x -e ";
552 std::string regex = "service";
553 std::string res = GetCmdResultFromPopen(cmd + regex);
554 if (res != "") {
555 vector<string> vec;
556 Split(res, vec, "\n");
557 for (auto& it : vec) {
558 EXPECT_TRUE(it.find(regex) != string::npos);
559 }
560 }
561
562 cmd = "hilog -x -e abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
563 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
564 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 2>&1";
565 std::string errMsg = ErrorCode2Str(ERR_REGEX_STR_TOO_LONG) + "\n";
566 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
567 }
568
569 /**
570 * @tc.name: Dfx_HilogToolTest_HandleTest_013
571 * @tc.desc: LevelHandler.
572 * @tc.type: FUNC
573 */
574 HWTEST_F(HilogToolTest, HandleTest_014, TestSize.Level1)
575 {
576 /**
577 * @tc.steps: step1. filter log level.
578 * @tc.steps: step2. invaild log level usage.
579 */
580 GTEST_LOG_(INFO) << "HandleTest_014: start.";
581 std::string cmd = "hilog -a 10 -L ";
582 std::string level = "I";
583 std::string res = GetCmdResultFromPopen(cmd + level);
584 vector<string> vec;
585 Split(res, vec, "\n");
586 for (auto& it : vec) {
587 std::string logLevel = it.substr(31, 1);
588 EXPECT_EQ(logLevel, level);
589 }
590
591 cmd = "hilog -L test_level 2>&1";
592 std::string errMsg = ErrorCode2Str(ERR_LOG_LEVEL_INVALID) + "\n";
593 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
594
595 cmd = "hilog -L E F 2>&1";
596 errMsg = ErrorCode2Str(ERR_TOO_MANY_ARGUMENTS) + "\n";
597 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
598
599 cmd = "hilog -L E -L F 2>&1";
600 errMsg = ErrorCode2Str(ERR_DUPLICATE_OPTION) + "\n";
601 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
602 }
603
604 /**
605 * @tc.name: Dfx_HilogToolTest_HandleTest_013
606 * @tc.desc: PidHandler.
607 * @tc.type: FUNC
608 */
609 HWTEST_F(HilogToolTest, HandleTest_015, TestSize.Level1)
610 {
611 /**
612 * @tc.steps: step1. filter PID.
613 */
614 GTEST_LOG_(INFO) << "HandleTest_015: start.";
615 std::string pid = GetCmdResultFromPopen("hilog -z 1").substr(19, 5);
616 std::string cmd = "hilog -a 10 -P ";
617 std::string res = GetCmdResultFromPopen(cmd + pid);
618 if (res != "") {
619 vector<string> vec;
620 Split(res, vec, "\n");
621 for (auto& it : vec) {
622 std::string logPid = it.substr(19, 5);
623 EXPECT_EQ(logPid, pid);
624 }
625 }
626
627 cmd = "hilog -P test 2>&1";
628 std::string errMsg = ErrorCode2Str(ERR_NOT_NUMBER_STR) + "\n";
629 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
630 }
631
632 /**
633 * @tc.name: Dfx_HilogToolTest_HandleTest_016
634 * @tc.desc: StatsInfoQueryHandler.
635 * @tc.type: FUNC
636 */
637 HWTEST_F(HilogToolTest, HandleTest_016, TestSize.Level1)
638 {
639 /**
640 * @tc.steps: step1. set stats property.
641 * @tc.steps: step2. restart hilog service.
642 * @tc.steps: step3. show log statistic report.
643 * @tc.steps: step4. clear hilogd statistic information.
644 */
645 GTEST_LOG_(INFO) << "HandleTest_016: start.";
646 (void)GetCmdResultFromPopen("param set persist.sys.hilog.stats false");
647 (void)GetCmdResultFromPopen("param set persist.sys.hilog.stats.tag false");
648 (void)GetCmdResultFromPopen("service_control stop hilogd");
649 (void)GetCmdResultFromPopen("service_control start hilogd");
650 sleep(3);
651 std::string cmd = "hilog -s";
652 std::string str = "Statistic info query failed";
653 EXPECT_TRUE(IsExistInCmdResult(cmd, str));
654
655 (void)GetCmdResultFromPopen("param set persist.sys.hilog.stats true");
656 (void)GetCmdResultFromPopen("param set persist.sys.hilog.stats.tag true");
657 (void)GetCmdResultFromPopen("service_control stop hilogd");
658 (void)GetCmdResultFromPopen("service_control start hilogd");
659 sleep(10);
660 str = "report";
661 EXPECT_TRUE(IsExistInCmdResult(cmd, str));
662 EXPECT_TRUE(IsStatsEnable());
663 EXPECT_TRUE(IsTagStatsEnable());
664
665 cmd = "hilog -S";
666 str = "Statistic info clear successfully\n";
667 EXPECT_EQ(GetCmdResultFromPopen(cmd), str);
668 }
669
670 /**
671 * @tc.name: Dfx_HilogToolTest_HandleTest_017
672 * @tc.desc: FormatHandler.
673 * @tc.type: FUNC
674 */
675 HWTEST_F(HilogToolTest, HandleTest_017, TestSize.Level1)
676 {
677 /**
678 * @tc.steps: step1. log format time.
679 * @tc.steps: step2. log format epoch.
680 * @tc.steps: step3. log format monotonic.
681 * @tc.steps: step4. log format msec.
682 * @tc.steps: step5. log format usec.
683 * @tc.steps: step6. log format nsec.
684 * @tc.steps: step7. log format year.
685 * @tc.steps: step8. log format zone.
686 * @tc.steps: step9. invalid log format.
687 */
688 GTEST_LOG_(INFO) << "HandleTest_017: start.";
689 std::string cmd = "hilog -v time -z 5";
690 std::regex pattern("(0\\d{1}|1[0-2])-(0\\d{1}|[12]\\d{1}|3[01])\\s(0\\d{1}|1\\d{1}|2[0-3])"
691 ":[0-5]\\d{1}:([0-5]\\d{1})(\\.(\\d){0,3})?$");
692 std::string res = GetCmdResultFromPopen(cmd);
693 vector<string> vec;
694 Split(res, vec, "\n");
695 for (auto& it : vec) {
696 EXPECT_TRUE(regex_match(it.substr(0, 18), pattern));
697 }
698
699 cmd = "hilog -v epoch -z 5";
700 pattern = ("\\d{0,10}.\\d{3}$");
701 res = GetCmdResultFromPopen(cmd);
702 Split(res, vec, "\n");
703 for (auto& it : vec) {
704 EXPECT_TRUE(regex_match(it.substr(0, 14), pattern));
705 }
706
707 cmd = "hilog -v monotonic -z 5";
708 pattern = ("\\d{0,8}.\\d{3}$");
709 res = GetCmdResultFromPopen(cmd);
710 std::string initStr = "HiLog: ========Zeroth log of type";
711 Split(res, vec, "\n");
712 for (auto& it : vec) {
713 if (it.find(initStr) == string::npos) {
714 std::string str = it.substr(0, 12);
715 // remove the head blank space
716 str.erase(0, str.find_first_not_of(" "));
717 EXPECT_TRUE(regex_match(str, pattern));
718 }
719 }
720
721 cmd = "hilog -v msec -z 5";
722 pattern = ("(0\\d{1}|1[0-2])-(0\\d{1}|[12]\\d{1}|3[01])\\s(0\\d{1}|1\\d{1}|2[0-3])"
723 ":[0-5]\\d{1}:([0-5]\\d{1})(\\.(\\d){0,3})?$");
724 res = GetCmdResultFromPopen(cmd);
725 Split(res, vec, "\n");
726 for (auto& it : vec) {
727 EXPECT_TRUE(regex_match(it.substr(0, 18), pattern));
728 }
729
730 cmd = "hilog -v usec -z 5";
731 pattern = "(0\\d{1}|1[0-2])-(0\\d{1}|[12]\\d{1}|3[01])\\s(0\\d{1}|1\\d{1}|2[0-3])"
732 ":[0-5]\\d{1}:([0-5]\\d{1})(\\.(\\d){0,6})?$";
733 res = GetCmdResultFromPopen(cmd);
734 Split(res, vec, "\n");
735 for (auto& it : vec) {
736 EXPECT_TRUE(regex_match(it.substr(0, 21), pattern));
737 }
738
739 cmd = "hilog -v nsec -z 5";
740 pattern = "(0\\d{1}|1[0-2])-(0\\d{1}|[12]\\d{1}|3[01])\\s(0\\d{1}|1\\d{1}|2[0-3])"
741 ":[0-5]\\d{1}:([0-5]\\d{1})(\\.(\\d){0,9})?$";
742 res = GetCmdResultFromPopen(cmd);
743 Split(res, vec, "\n");
744 for (auto& it : vec) {
745 EXPECT_TRUE(regex_match(it.substr(0, 24), pattern));
746 }
747
748 cmd = "hilog -v year -z 5";
749 pattern = "(\\d{4})-(0\\d{1}|1[0-2])-(0\\d{1}|[12]\\d{1}|3[01])\\s(0\\d{1}|1\\d{1}|2[0-3])"
750 ":[0-5]\\d{1}:([0-5]\\d{1})(\\.(\\d){0,3})?$";
751 res = GetCmdResultFromPopen(cmd);
752 Split(res, vec, "\n");
753 for (auto& it : vec) {
754 EXPECT_TRUE(regex_match(it.substr(0, 23), pattern));
755 }
756
757 cmd = "hilog -v zone -z 5";
758 std::regex gmtPattern("GMT (0\\d{1}|1[0-2])-(0\\d{1}|[12]\\d{1}|3[01])\\s(0\\d{1}|1\\d{1}|2[0-3])"
759 ":[0-5]\\d{1}:([0-5]\\d{1})(\\.(\\d){0,3})?$");
760 std::regex cstPattern("CST (0\\d{1}|1[0-2])-(0\\d{1}|[12]\\d{1}|3[01])\\s(0\\d{1}|1\\d{1}|2[0-3])"
761 ":[0-5]\\d{1}:([0-5]\\d{1})(\\.(\\d){0,3})?$");
762 res = GetCmdResultFromPopen(cmd);
763 Split(res, vec, "\n");
764 for (auto& it : vec) {
765 EXPECT_TRUE(regex_match(it.substr(0, 22), gmtPattern) || regex_match(it.substr(0, 22), cstPattern));
766 }
767
768 cmd = "hilog -v test 2>&1";
769 std::string errMsg = ErrorCode2Str(ERR_INVALID_ARGUMENT) + "\n";
770 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
771
772 cmd = "hilog -v time -v epoch 2>&1";
773 errMsg = ErrorCode2Str(ERR_DUPLICATE_OPTION) + "\n";
774 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
775
776 cmd = "hilog -v msec -v usec 2>&1";
777 errMsg = ErrorCode2Str(ERR_DUPLICATE_OPTION) + "\n";
778 EXPECT_EQ(GetCmdResultFromPopen(cmd), errMsg);
779
780 cmd = "hilog -x -v color";
781 EXPECT_GT(GetCmdLinesFromPopen(cmd), 0);
782 }
783
784 /**
785 * @tc.name: Dfx_HilogToolTest_HandleTest_018
786 * @tc.desc: QueryLogHandler.
787 * @tc.type: FUNC
788 */
789 HWTEST_F(HilogToolTest, HandleTest_018, TestSize.Level1)
790 {
791 /**
792 * @tc.steps: step1. query log of specific pid.
793 * @tc.steps: step2. query log of specific domain.
794 * @tc.steps: step3. query log of specific tag.
795 */
796 GTEST_LOG_(INFO) << "HandleTest_018: start.";
797 std::string res = GetCmdResultFromPopen("hilog -z 1");
798 std::string pid = res.substr(19, 5);
799 std::string domain = res.substr(34, 5);
800 int tagLen = res.substr(40).find(":") + 1;
801 std::string tag = res.substr(40, tagLen);
802 std::string queryDomainCmd = "hilog -x -D d0" + domain;
803 std::string queryPidCmd = "hilog -x -P " + pid;
804 std::string queryTagCmd = "hilog -x -T " + tag;
805 vector<string> vec;
806
807 res = GetCmdResultFromPopen(queryPidCmd);
808 if (res != "") {
809 Split(res, vec, "\n");
810 for (auto& it : vec) {
811 std::string logPid = it.substr(19, 5);
812 EXPECT_EQ(logPid, pid);
813 }
814 }
815
816 res = GetCmdResultFromPopen(queryDomainCmd);
817 if (res != "") {
818 Split(res, vec, "\n");
819 for (auto& it : vec) {
820 std::string logDomain = it.substr(34, 5);
821 EXPECT_EQ(logDomain, domain);
822 }
823 }
824
825 res = GetCmdResultFromPopen(queryTagCmd);
826 if (res != "") {
827 Split(res, vec, "\n");
828 for (auto& it : vec) {
829 std::string logTag = it.substr(40, tagLen);
830 EXPECT_EQ(logTag, tag);
831 }
832 }
833 }
834
835 /**
836 * @tc.name: Dfx_HilogToolTest_HandleTest_019
837 * @tc.desc: tag & domain level ctl.
838 * @tc.type: FUNC
839 */
840 HWTEST_F(HilogToolTest, HandleTest_019, TestSize.Level1)
841 {
842 /**
843 * @tc.steps: step1. tag level ctl.
844 * @tc.steps: step2. domain level ctl.
845 */
846 GTEST_LOG_(INFO) << "HandleTest_019: start.";
847 std::string res = GetCmdResultFromPopen("hilog -z 1");
848 uint32_t domain = std::stoi(res.substr(34, 5));
849 int tagLen = res.substr(40).find(":") + 1;
850 std::string tag = res.substr(40, tagLen);
851
852 // Priority: TagLevel > DomainLevel > GlobalLevel
853 SetTagLevel(tag, LOG_ERROR);
854 SetDomainLevel(domain, LOG_INFO);
855 EXPECT_FALSE(HiLogIsLoggable(domain, tag.c_str(), LOG_INFO));
856 EXPECT_TRUE(HiLogIsLoggable(domain, tag.c_str(), LOG_ERROR));
857
858 SetTagLevel(tag, LOG_INFO);
859 SetDomainLevel(domain, LOG_ERROR);
860 EXPECT_TRUE(HiLogIsLoggable(domain, tag.c_str(), LOG_INFO));
861 EXPECT_TRUE(HiLogIsLoggable(domain, tag.c_str(), LOG_ERROR));
862
863 // restore log level
864 SetDomainLevel(domain, LOG_INFO);
865 }
866 } // namespace
867