add hilog test

Signed-off-by: Naajwy <13051180828@163.com>

hiviewdfx/hilogtest/libhilogtest/BUILD.gn

@@ -16,5 +16,6 @@ group("libhilogtestacts") {
   deps = [
     "libhilogCPPtest:LibhilogCPPtest",
     "libhilogCtest:libhilogCtest",
+    "hilogtest:hilogtest",
   ]
 }

hiviewdfx/hilogtest/libhilogtest/hilogtest/BUILD.gn

+# Copyright (C) 2021 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//test/xts/tools/build/suite.gni")
+module_output_path = "hits/hilogtest"
+
+###############################################################################
+config("hilogtest_config") {
+  visibility = [ ":*" ]
+  include_dirs = [
+    "../../../utils/native",
+    "//utils/native/base/include/",
+    "//base/hiviewdfx/hilog/interfaces/native/innerkits/include",
+  ]
+}
+ohos_moduletest_suite("hilogtest") {
+  module_out_path = module_output_path
+  sources = [ "hilogtest.cpp" ]
+  deps = [
+    "../../../utils/native:utilskit",
+    "//base/hiviewdfx/hilog/interfaces/native/innerkits:libhilog",
+    "//third_party/googletest:gtest_main",
+    "//utils/native/base:utils",
+  ]
+
+  #external_deps = [ "hiviewdfx_hilog_native:libhilog" ]
+  configs = [ ":hilogtest_config" ]
+}

hiviewdfx/hilogtest/libhilogtest/hilogtest/Test.json

+{
+    "kits": [
+        {
+            "push": [
+                "libhilogTooltest->/data/local/tmp/libhilogTooltest"
+            ],
+            "type": "PushKit",
+            "post-push": [
+                "chmod -R 777 /data/local/tmp/*"
+            ]
+        }
+    ],
+    "driver": {
+        "native-test-timeout": "120000",
+        "type": "CppTest",
+        "module-name": "libhilogTooltest",
+        "runtime-hint": "1s",
+        "native-test-device-path": "/data/local/tmp"
+    },
+    "description": "Configuration for libhilogTooltest Tests"
+}
\ No newline at end of file

hiviewdfx/hilogtest/libhilogtest/hilogtest/hilogtest.cpp

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <cstdarg>
+#include <ctime>
+#include <gtest/gtest.h>
+#include <list>
+#include <ostream>
+#include <pthread.h>
+#include <queue>
+#include <regex>
+#include <securec.h>
+#include <streambuf>
+#include <sys/time.h>
+#include <thread>
+
+#include "file_utils.h"
+#include "hilog/log_c.h"
+#include "hilog/log_cpp.h"
+
+#undef LOG_DOMAIN
+#undef LOG_TAG
+#define LOG_DOMAIN 0xD003200
+#define LOG_TAG "HILOGTOOLTEST"
+#define MAX_LINE  1024*10
+using namespace OHOS;
+using namespace HiviewDFX;
+using namespace testing::ext;
+using namespace std;
+
+class LibhilogTooltest : public testing::Test {
+public:
+    string input, result, expect;
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp();
+    void TearDown();
+    string gHilogtoolExecutable = "hilog ";
+    string g_logContent = "123456789_1234567890_public and private log test is:\
+    %{public}d, %{private}lf, %{public}.2f, %s, %{private}c\n";
+    string g_commonContent = "03200/HILOGTOOLTEST: 123456789_1234567890_public and private log test is:";
+private:
+
+};
+void LibhilogTooltest::SetUp()
+{
+}
+void LibhilogTooltest::TearDown()
+{
+}
+void LibhilogTooltest::SetUpTestCase()
+{
+    ExeCmd("hilog -p on");
+    ExeCmd("hilog -Q domainoff");
+    ExeCmd("hilog -Q pidoff");
+    ExeCmd("hilog -b debug");
+    ExeCmd("hilog -b debug -D 218116608");
+    ExeCmd("hilog -b debug -T HILOGTOOLTEST");
+    ExeCmd("hilog -r -t all");
+    ExeCmd("hilog -G 1m -t all");
+    ExeCmd("hilog -S -t all");
+    ExeCmd("hilog -S -D 218116608");
+}
+void LibhilogTooltest::TearDownTestCase()
+{
+    ExeCmd("hilog -p on");
+    ExeCmd("hilog -Q domainoff");
+    ExeCmd("hilog -Q pidoff");
+    ExeCmd("hilog -b debug");
+    ExeCmd("hilog -b debug -D 218116608");
+    ExeCmd("hilog -b debug -T HILOGTOOLTEST");
+    ExeCmd("hilog -r -t all");
+    ExeCmd("hilog -G 1m -t all");
+    ExeCmd("hilog -S -t all");
+    ExeCmd("hilog -S -D 218116608");
+    std::cout << "TearDownTestCase" << std::endl;
+}
+
+
+/*
+ * @tc.name one-time read
+ * @tc.number DFX_DFT_HilogCPP_0840
+ * @tc.desc one-time read
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_exit, Function|MediumTest|Level3)
+{
+    CleanCmd();
+    std::string saveFile= "test_data_31.txt";
+    std::string cmd1 = gHilogtoolExecutable + " -r";
+    std::string cmdResult;
+    CmdRun(cmd1, cmdResult);
+    LogType type = LOG_APP;
+    int i = 0;
+    while (i++ <= 5) {
+        usleep(1000);
+        HILOG_DEBUG(type, g_logContent.c_str(), i, 1.00001, 2.333333, "sse", 'a');
+    }
+    std::string cmd2 = gHilogtoolExecutable + "-T HILOGTOOLTEST -x";
+    SaveCmdOutput(cmd2, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    std::vector<std::string> para = {g_commonContent};
+    if (hilogInfo != "") {
+        result = CheckInfo(para, hilogInfo);
+    } else {
+        std::cout << "Hilogtool_exit error" << std::endl;
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name The log tool can read app log types at a time.
+ * @tc.number DFX_DFT_HilogCPP_0860
+ * @tc.desc The log tool can read app log types at a time.
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_type_app, Function|MediumTest|Level3)
+{
+    CleanCmd();
+    std::string saveFile= "test_data_33_1.txt";
+    LogType type = LOG_APP;
+    int i = 0;
+    while (i++ <= 5) {
+        usleep(1000);
+        HILOG_DEBUG(type, g_logContent.c_str(), i, 1.00001, 2.333333, "sse", 'a');
+    }
+    std::string cmd = gHilogtoolExecutable + " -t app -x ";
+    SaveCmdOutput(cmd, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    std::vector<std::string> para = {g_commonContent};
+    if (hilogInfo != " ") {
+        result = CheckInfo(para, hilogInfo);
+    } else {
+        std::cout << "Hilogtool_type_app error";
+    }
+    ASSERT_TRUE(true == result);
+}
+
+
+/*
+ * @tc.name The log tool can read core log types at a time.
+ * @tc.number DFX_DFT_HilogCPP_0870
+ * @tc.desc The log tool can read core log types at a time
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_type_core, Function|MediumTest|Level3)
+{
+    CleanCmd();
+    std::string saveFile= "test_data_33_2.txt";
+    LogType type = LOG_CORE;
+    int i = 0;
+    while (i++ <= 5) {
+        usleep(1000);
+        HILOG_DEBUG(type, g_logContent.c_str(), i, 1.00001, 2.333333, "sse", 'a');
+    }
+    std::string cmd = gHilogtoolExecutable + " -t core -x ";
+    SaveCmdOutput(cmd, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    std::vector<std::string> para = {g_commonContent};
+    if (hilogInfo != "") {
+        result = CheckInfo(para, hilogInfo);
+    } else {
+        std::cout << "Hilogtool_type_app error"<<std::endl;
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name The log tool can read init log types at a time.
+ * @tc.number DFX_DFT_HilogCPP_0880
+ * @tc.desc The log tool can read init log types at a time.
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_type_init, Function|MediumTest|Level3)
+{
+    CleanCmd();
+    std::string saveFile= "test_data_33_3.txt";
+    LogType type = LOG_INIT;
+    int i = 0;
+    while (i++ <= 5) {
+        usleep(1000);
+        HILOG_DEBUG(type, g_logContent.c_str(), i, 1.00001, 2.333333, "sse", 'a');
+    }
+    std::string cmd = gHilogtoolExecutable + " -t init -x ";
+    SaveCmdOutput(cmd, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    std::vector<std::string> para = {g_commonContent};
+    if (hilogInfo != "") {
+        result = CheckInfo(para, hilogInfo);
+    } else {
+        std::cout << "Hilogtool_type_init error";
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name The log tool can read Hilogtool_type_multiple log types at a time.
+ * @tc.number DFX_DFT_HilogCPP_0890
+ * @tc.desc The log tool can read Hilogtool_type_multiple log types at a time.
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_type_multiple, Function|MediumTest|Level2)
+{
+    CleanCmd();
+    std::string saveFile= "test_data_33_4.txt";
+    LogType type = LOG_INIT;
+    int i = 0;
+    while (i++ <= 3) {
+        usleep(1000);
+        HILOG_DEBUG(type, g_logContent.c_str(), i, 1.00001, 2.333333, "sse", 'a');
+        type = LOG_INIT;
+        HILOG_DEBUG(type, g_logContent.c_str(), i, 1.00001, 2.333333, "sse", 'a');
+        type = LOG_APP;
+        HILOG_DEBUG(type, g_logContent.c_str(), i, 1.00001, 2.333333, "sse", 'a');
+    }
+    std::string cmd = gHilogtoolExecutable + "-D 0xd003200 -t app core init -x ";
+    SaveCmdOutput(cmd, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    std::vector<std::string> para = {g_commonContent};
+    if (hilogInfo != "") {
+        result = CheckInfo(para, hilogInfo);
+    } else {
+        std::cout << "Hilogtool_type_multiple error";
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name show local time
+ * @tc.number DFX_DFT_HilogCPP_0950
+ * @tc.desc show local time
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_time, Function|MediumTest|Level3)
+{
+    std::string cmd = gHilogtoolExecutable + " -a 1 -v time ";
+    std::string saveFile= "test_data_35_1.txt";
+    SaveCmdOutput(cmd, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    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]):[0-5]\\d{1}:([0-5]\\d{1})(\\.(\\d){0,3})?$");
+    std::cout << hilogInfo.substr(0, 18);
+    string timeBuffer = hilogInfo.substr(0, 18);
+    std::smatch match;
+    bool ismatch = regex_match(timeBuffer, match, pattern);
+    if (ismatch) {
+        std::cout<<"match successed"<<std::endl;
+        result = true;
+    } else {
+        std::cout<<"match failed"<<std::endl;
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name show the time from 1970
+ * @tc.number DFX_DFT_HilogCPP_0960
+ * @tc.desc show the time from 1970
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_epoch, Function|MediumTest|Level4)
+{
+    std::string cmd = gHilogtoolExecutable + " -a 1 -v epoch ";
+    std::string saveFile= "test_data_35_2.txt";
+    SaveCmdOutput(cmd, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    std::regex pattern("[^0-9]");
+    std::cout << hilogInfo.substr(0, 19);
+    string timeBuffer = hilogInfo.substr(0, 19);
+    std::smatch match;
+    bool ismatch = regex_search(timeBuffer, match, pattern);
+    if (ismatch) {
+        std::cout << "match successed" << std::endl;
+        result = true;
+    } else {
+        std::cout <<"match failed"<< std::endl;
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name show the time from last restart
+ * @tc.number DFX_DFT_HilogCPP_0970
+ * @tc.desc show the time from last restart
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_monotonic, Function|MediumTest|Level3)
+{
+    std::string cmd = gHilogtoolExecutable + " -a 1 -v monotonic";
+    std::string saveFile= "test_data_35_3.txt";
+    SaveCmdOutput(cmd, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    std::regex pattern("[^0-9]");
+    std::cout << hilogInfo.substr(0, 14);
+    string timeBuffer = hilogInfo.substr(0, 14);
+    std::smatch match;
+    bool ismatch = regex_search(timeBuffer, match, pattern);
+    if (ismatch) {
+        std::cout << "match successed"  << std::endl;
+        result = true;
+    } else {
+        std::cout << "match failed" << std::endl;
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name Displays time in microsecond accuracy
+ * @tc.number DFX_DFT_HilogCPP_0980
+ * @tc.desc Displays time in microsecond accuracy
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_usec, Function|MediumTest|Level4)
+{
+    std::string cmd = gHilogtoolExecutable + " -a 1 -v usec";
+    std::string saveFile= "test_data_35_4.txt";
+    SaveCmdOutput(cmd, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    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]):[0-5]\\d{1}:([0-5]\\d{1})(\\.(\\d){0,6})?$");
+    std::cout << hilogInfo.substr(0, 21);
+    string timeBuffer = hilogInfo.substr(0, 21);
+    std::smatch match;
+    bool ismatch = regex_match(timeBuffer, match, pattern);
+    if (ismatch) {
+        std::cout << "match successed"  << std::endl;
+        result = true;
+    } else {
+        std::cout << "match failed" << std::endl;
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name Displays time in nanosecond precision.
+ * @tc.number DFX_DFT_HilogCPP_0990
+ * @tc.desc Displays time in nanosecond precision.
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_nsec, Function|MediumTest|Level4)
+{
+    std::string cmd = gHilogtoolExecutable + " -a 1 -v nsec";
+    std::string saveFile= "test_data_35_5.txt";
+    SaveCmdOutput(cmd, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    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]):[0-5]\\d{1}:([0-5]\\d{1})(\\.(\\d){0,9})?$");
+
+    std::cout << hilogInfo.substr(0, 24);
+    string timeBuffer = hilogInfo.substr(0, 24);
+    std::smatch match;
+    bool ismatch = regex_match(timeBuffer, match, pattern);
+    if (ismatch) {
+        std::cout << "match successed"<< std::endl;
+        result = true;
+    } else {
+        std::cout << "match failed"<< std::endl;
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name added year to the displayed time.
+ * @tc.number DFX_DFT_HilogCPP_1000
+ * @tc.desc added year to the displayed time.
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_year, Function|MediumTest|Level4)
+{
+    std::string cmd = gHilogtoolExecutable + " -a 1 -v year";
+    char saveFile356[] = "test_data_35_6.txt";
+    SaveCmdOutput(cmd, saveFile356);
+    string hilogInfo = ReadFile(saveFile356);
+    bool result = false;
+    std::regex 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]):[0-5]\\d{1}:([0-5]\\d{1})(\\.(\\d){0,3})?$");
+    std::cout << hilogInfo.substr(0, 23);
+    string timeBuffer = hilogInfo.substr(0, 23);
+    std::smatch match;
+    bool ismatch = regex_match(timeBuffer, match, pattern);
+    if (ismatch) {
+        std::cout << "match successed"<< std::endl;
+        result = true;
+    } else {
+        std::cout << "match failed"<< std::endl;
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name show the local time zone
+ * @tc.number DFX_DFT_HilogCPP_1010
+ * @tc.desc show the local time zone
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_zone, Function|MediumTest|Level4)
+{
+    std::string cmd = gHilogtoolExecutable + " -a 1 -v zone";
+    std::string saveFile= "test_data_35_6.txt";
+    SaveCmdOutput(cmd, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    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]):[0-5]\\d{1}:([0-5]\\d{1})");
+    std::cout << hilogInfo.substr(0, 20);
+    string timeBuffer = hilogInfo.substr(0, 20);
+    std::smatch match;
+    bool ismatch = regex_match(timeBuffer, match, pattern);
+    if (ismatch) {
+        std::cout << "match successed"<< std::endl;
+        result = true;
+    } else {
+        std::cout << "match failed"<< std::endl;
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name Filtering by regular expression, The expression is empty.
+ * @tc.number DFX_DFT_HilogCPP_1870
+ * @tc.desc Filtering by regular expression, The expression is empty.
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_regex_null, Function|MediumTest|Level3)
+{
+    CleanCmd();
+    std::string cmd = gHilogtoolExecutable + " -x -e \"\"";
+    // " -type app core init -x "
+    std::string saveFile= "test_data_46_1.txt";
+    SaveCmdOutput(cmd, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    std::vector<std::string> para = {g_commonContent};
+    if (hilogInfo != " ") {
+        result = CheckInfo(para, hilogInfo);
+    } else {
+        std::cout << "Hilogtool_regex_null error";
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name Filtering by regular expression
+ * @tc.number DFX_DFT_HilogCPP_1880
+ * @tc.desc Filtering by regular expression
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_regex, Function|MediumTest|Level3)
+{
+    CleanCmd();
+    std::string cmd1 = gHilogtoolExecutable + " -x -e \"^(123)\"";
+
+    char saveFile462[] = "test_data_46_2.txt";
+    SaveCmdOutput(cmd1, saveFile462);
+    string hilogInfo = ReadFile(saveFile462);
+    bool result = false;
+    std::vector<std::string> para = {"03200/HILOGTOOLTEST"};
+    if (hilogInfo != "") {
+        result = CheckInfo(para, hilogInfo);
+    } else {
+        std::cout << "Hilogtool_regex error";
+    }
+    ASSERT_TRUE(true == result);
+    CleanCmd();
+    std::string cmd2 = gHilogtoolExecutable + " -x -e \"^(www)\"";
+    char saveFile463[] = "test_data_46_3.txt";
+    SaveCmdOutput(cmd2, saveFile463);
+    hilogInfo = ReadFile(saveFile463);
+    if (hilogInfo != " ") {
+        result = CheckInfo(para, hilogInfo);
+    } else {
+        std::cout << "Hilogtool_regex error";
+    }
+    ASSERT_TRUE(false == result);
+}
+
+/*
+ * @tc.name show the first 1 row
+ * @tc.number DFX_DFT_HilogCPP_1890
+ * @tc.desc show the first 1 row
+*/
+
+HWTEST_F(LibhilogTooltest, Hilogtool_head_1, Function|MediumTest|Level3)
+{
+    CleanCmd();
+    LogType type = LOG_INIT;
+    int cnt =20;
+    int i = 0;
+    while (i++ <= cnt) {
+        usleep(1);
+        HILOG_DEBUG(type, g_logContent.c_str(), i, 1.00001, 2.333333, "sse", 'a');
+    }
+    std::string cmd = gHilogtoolExecutable + " -a 1 -x ";
+    std::string saveFile = "test_data_47_1.txt";
+    SaveCmdOutput(cmd, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    std::vector<std::string> para = {g_commonContent};
+    if (hilogInfo != " ") {
+        result = CheckInfo(para, hilogInfo);
+    } else {
+        std::cout << "Hilogtool_n error";
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name show first 20 rows
+ * @tc.number DFX_DFT_HilogCPP_1900
+ * @tc.desc show first 20 rows
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_head_20, Function|MediumTest|Level4)
+{
+    CleanCmd();
+    LogType type = LOG_INIT;
+    int cnt =20;
+    int i = 0;
+    while (i++ <= cnt) {
+        usleep(1);
+        HILOG_DEBUG(type, g_logContent.c_str(), i, 1.00001, 2.333333, "sse", 'a');
+    }
+    std::string saveFile= "test_data_47_2.txt";
+    std::string cmd = gHilogtoolExecutable + " -a 20 -x ";
+    SaveCmdOutput(cmd, saveFile);
+    int n = GetTxtLine(saveFile);
+    ASSERT_TRUE(n == 20);
+}
+
+/*
+ * @tc.name show the last 1 row
+ * @tc.number DFX_DFT_HilogCPP_1910
+ * @tc.desc show the last 1 row
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_tail_1, Function|MediumTest|Level4)
+{
+    CleanCmd();
+    LogType type = LOG_INIT;
+    int cnt =20;
+    int i = 0;
+    while (i++ <= cnt) {
+        usleep(1);
+        HILOG_DEBUG(type, g_logContent.c_str(), i, 1.00001, 2.333333, "sse", 'a');
+    }
+    std::string saveFile= "test_data_47_3.txt";
+    std::string cmd = gHilogtoolExecutable + "-t init -z 1";
+    SaveCmdOutput(cmd, saveFile);
+    sleep(2);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    std::vector<std::string> para = {g_commonContent};
+    if (hilogInfo != " ") {
+        result = CheckInfo(para, hilogInfo);
+    } else {
+        std::cout << "Hilogtool_n error";
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name show last 20 rows
+ * @tc.number DFX_DFT_HilogCPP_1920
+ * @tc.desc show last 20 rows
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_tail_20, Function|MediumTest|Level4)
+{
+    CleanCmd();
+    LogType type = LOG_INIT;
+    int cnt =20;
+    int i = 0;
+    while (i++ <= cnt) {
+        usleep(1);
+        HILOG_DEBUG(type, g_logContent.c_str(), i, 1.00001, 2.333333, "sse", 'a');
+    }
+    std::string saveFile= "test_data_47_4.txt";
+    std::string cmd = gHilogtoolExecutable + "-t init -z 20";
+    SaveCmdOutput(cmd, saveFile);
+    int n = GetTxtLine(saveFile);
+    ASSERT_TRUE(n == 20);
+}
+
+/*
+ * @tc.name The filtering parameter is empty.
+ * @tc.number DFX_DFT_HilogCPP_1930
+ * @tc.desc The filtering parameter is empty.
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_filter_null, Function|MediumTest|Level4)
+{
+    CleanCmd();
+    LogType type = LOG_INIT;
+
+    int cnt =20;
+    int i = 0;
+    while (i++ <= cnt) {
+        usleep(1000);
+        HILOG_DEBUG(type, g_logContent.c_str(), i, 1.00001, 2.333333, "sse", 'a');
+    }
+    std::string saveFile= "test_data_48_1.txt";
+    std::string cmd = gHilogtoolExecutable + " -t init  -x";
+    SaveCmdOutput(cmd, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    std::vector<std::string> para = {g_commonContent};
+    if (hilogInfo != "") {
+        result = CheckInfo(para, hilogInfo);
+    } else {
+        std::cout << "Hilogtool_filter error";
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name Filter level only.
+ * @tc.number DFX_DFT_HilogCPP_1960
+ * @tc.desc Filter level only.
+*/
+
+HWTEST_F(LibhilogTooltest, Hilogtool_filter_level, Function|MediumTest|Level4)
+{
+    CleanCmd();
+    LogType type = LOG_INIT;
+    int cnt =20;
+    int i = 0;
+    while (i++ <= cnt) {
+        usleep(1);
+        HILOG_DEBUG(type, g_logContent.c_str(), i, 1.00001, 2.333333, "sse", 'a');
+    }
+    std::string saveFile= "test_data_48_4.txt";
+    std::string cmd = gHilogtoolExecutable + " -t init -L D -x";
+    SaveCmdOutput(cmd, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    std::vector<std::string> para = {g_commonContent};
+    if (hilogInfo != "") {
+        result = CheckInfo(para, hilogInfo);
+    } else {
+        std::cout << "Hilogtool_filter error";
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name Filter domain only.
+ * @tc.number DFX_DFT_HilogCPP_1970
+ * @tc.desc Filter domain only.
+*/
+
+HWTEST_F(LibhilogTooltest, Hilogtool_filter_domain, Function|MediumTest|Level3)
+{
+    CleanCmd();
+    LogType type = LOG_INIT;
+
+    int cnt =20;
+    int i = 0;
+    while (i++ <= cnt) {
+        usleep(1);
+        HILOG_DEBUG(type, g_logContent.c_str(), i, 1.00001, 2.333333, "sse", 'a');
+    }
+    std::string saveFile= "test_data_48_3.txt";
+    std::string cmd = gHilogtoolExecutable + " -t init -D 0xd003200 -x";
+    SaveCmdOutput(cmd, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    std::vector<std::string> para = {g_commonContent};
+    if (hilogInfo != "") {
+        result = CheckInfo(para, hilogInfo);
+    } else {
+        std::cout << "Hilogtool_filter error";
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name Filter tag only.
+ * @tc.number DFX_DFT_HilogCPP_1980
+ * @tc.desc Filter tag only.
+*/
+HWTEST_F(LibhilogTooltest, Hilogtool_filter_tag, Function|MediumTest|Level4)
+{
+    CleanCmd();
+    LogType type = LOG_INIT;
+    int cnt = 20;
+    int i = 0;
+    while (i++ <= cnt) {
+        usleep(1);
+        HILOG_DEBUG(type, g_logContent.c_str(), i, 1.00001, 2.333333, "sse", 'a');
+    }
+    std::string saveFile= "test_data_48_5.txt";
+    std::string cmd = gHilogtoolExecutable + " -T HILOGTOOLTEST -x";
+    SaveCmdOutput(cmd, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    std::vector<std::string> para = {g_commonContent};
+    if (hilogInfo != " ") {
+        result = CheckInfo(para, hilogInfo);
+    } else {
+        std::cout << "Hilogtool_filter error";
+    }
+    ASSERT_TRUE(true == result);
+}
+
+/*
+ * @tc.name Filter Multi-parameter
+ * @tc.number DFX_DFT_HilogCPP_1990
+ * @tc.desc Filter Multi-parameter
+*/
+
+HWTEST_F(LibhilogTooltest, Hilogtool_filter_multiple, Function|MediumTest|Level2)
+{
+    CleanCmd();
+    LogType type = LOG_INIT;
+    int i = 0;
+    int cnt = 20;
+    while (i++ <= cnt) {
+        usleep(1);
+        HILOG_DEBUG(type, g_logContent.c_str(), i, 1.00001, 2.333333, "sse", 'a');
+    }
+    std::string saveFile= "test_data_48_6.txt";
+    std::string cmd = gHilogtoolExecutable + \
+    " -T HILOGTOOLTEST -L D -x";
+    SaveCmdOutput(cmd, saveFile);
+    string hilogInfo = ReadFile(saveFile);
+    bool result = false;
+    std::vector<std::string> para = {g_commonContent};
+    if (hilogInfo != " ") {
+        result = CheckInfo(para, hilogInfo);
+    } else {
+        std::cout << "Hilogtool_filter error";
+    }
+    ASSERT_TRUE(true == result);
+}