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