xref: /developtools/profiler/device/cmds/test/unittest/hiprofiler_cmd_test.cpp

/*
 * Copyright (c) Huawei Technologies Co., Ltd. 2021. All rights reserved.
 * 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 <array>
#include <dlfcn.h>
#include <fcntl.h>
#include <gtest/gtest.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <unistd.h>

#include "logging.h"
#include "openssl/sha.h"

using namespace testing::ext;

#define HHB(v) (((v) & 0xF0) >> 4)
#define LHB(v)  ((v) & 0x0F)

namespace {
#if defined(__LP64__)
const std::string DEFAULT_SO_PATH("/system/lib64/");
#else
const std::string DEFAULT_SO_PATH("/system/lib/");
#endif
const std::string DEFAULT_HIPROFILERD_PATH("/system/bin/hiprofilerd");
const std::string DEFAULT_HIPROFILER_PLUGINS_PATH("/system/bin/hiprofiler_plugins");
const std::string DEFAULT_HIPROFILERD_NAME("hiprofilerd");
const std::string DEFAULT_HIPROFILER_PLUGINS_NAME("hiprofiler_plugins");

const std::string DEFAULT_HIPROFILER_CMD_PATH("/system/bin/hiprofiler_cmd");
const std::string FTRACE_PLUGIN_PATH("/data/local/tmp/libftrace_plugin.z.so");
const std::string HIPERF_PLUGIN_PATH("/data/local/tmp/libhiperfplugin.z.so");
std::string DEFAULT_PATH("/data/local/tmp/");
constexpr uint32_t READ_BUFFER_SIZE = 1024;
constexpr int SLEEP_TIME = 3;
constexpr int FILE_READ_CHUNK_SIZE = 4096;
constexpr char HEX_CHARS[] = "0123456789abcdef";
constexpr int LINE_SIZE = 1000;


class HiprofilerCmdTest : public ::testing::Test {
public:
    static void SetUpTestCase() {}
    static void TearDownTestCase() {}

    void StartServerStub(std::string name)
    {
        if (signal(SIGCHLD, SIG_IGN) == SIG_ERR) {
            return;
        }
        int processNum = fork();
        if (processNum == 0) {
            if (DEFAULT_HIPROFILERD_PATH == name) {
                // start running hiprofilerd
                execl(name.c_str(), nullptr, nullptr);
            } else if (DEFAULT_HIPROFILER_PLUGINS_PATH == name) {
                // start running hiprofiler_plugins
                execl(name.c_str(), DEFAULT_PATH.c_str(), nullptr);
            }
            _exit(1);
        } else if (DEFAULT_HIPROFILERD_PATH == name) {
            hiprofilerdPid_ = processNum;
        } else if (DEFAULT_HIPROFILER_PLUGINS_PATH == name) {
            hiprofilerPluginsPid_ = processNum;
        }
    }

    void StopProcessStub(int processNum)
    {
        std::string stopCmd = "kill " + std::to_string(processNum);
        std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(stopCmd.c_str(), "r"), pclose);
        sleep(SLEEP_TIME); // wait process exit
    }

    bool RunCommand(const std::string& cmd, std::string& content)
    {
        std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(cmd.c_str(), "r"), pclose);
        CHECK_TRUE(pipe, false, "RunCommand: create popen FAILED!");
        std::array<char, READ_BUFFER_SIZE> buffer;
        while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
            content += buffer.data();
        }
        return true;
    }

    std::string ComputeFileSha256(const std::string& path)
    {
        uint8_t out[SHA256_DIGEST_LENGTH];
        uint8_t buffer[FILE_READ_CHUNK_SIZE];
        char realPath[PATH_MAX + 1] = {0};

        SHA256_CTX sha;
        SHA256_Init(&sha);

        size_t nbytes = 0;

        if ((strlen(path.c_str()) >= PATH_MAX) || (realpath(path.c_str(), realPath) == nullptr)) {
            PROFILER_LOG_ERROR(LOG_CORE, "%s:path is invalid: %s, errno=%d", __func__, path.c_str(), errno);
            return "";
        }
        FILE* file = fopen(realPath, "rb");
        if (file == nullptr) {
            return "";
        }

        std::unique_ptr<FILE, decltype(fclose)*> fptr(file, fclose);
        if (fptr == nullptr) {
            return "";
        }

        while ((nbytes = fread(buffer, 1, sizeof(buffer), fptr.get())) > 0) {
            SHA256_Update(&sha, buffer, nbytes);
        }
        SHA256_Final(out, &sha);

        std::string result;
        result.reserve(SHA256_DIGEST_LENGTH + SHA256_DIGEST_LENGTH);
        for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
            result.push_back(HEX_CHARS[HHB(out[i])]);
            result.push_back(HEX_CHARS[LHB(out[i])]);
        }

        PROFILER_LOG_DEBUG(LOG_CORE, "%s:%s-(%s)", __func__, path.c_str(), result.c_str());
        return result;
    }

    void CreateConfigFile(const std::string configFile)
    {
        // 构建config文件
        std::string configStr =
            "request_id: 26\n"
            "session_config {\n"
            "  buffers {\n"
            "    pages: 1000\n"
            "  }\n"
            "  result_file: \"/data/local/tmp/hiprofiler_data.htrace\"\n"
            "  sample_duration: 10000\n"
            "}\n"
            "plugin_configs {\n"
            "  plugin_name: \"ftrace-plugin\"\n"
            "  sample_interval: 2000\n"
            "  config_data: {\n"
            "    ftrace_events: \"sched/sched_switch\"\n"
            "    ftrace_events: \"sched/sched_wakeup\"\n"
            "    ftrace_events: \"sched/sched_wakeup_new\"\n"
            "    ftrace_events: \"sched/sched_waking\"\n"
            "    ftrace_events: \"sched/sched_process_exit\"\n"
            "    ftrace_events: \"sched/sched_process_free\"\n"
            "    buffer_size_kb: 51200\n"
            "    flush_interval_ms: 1000\n"
            "    flush_threshold_kb: 4096\n"
            "    parse_ksyms: true\n"
            "    clock: \"mono\"\n"
            "    trace_period_ms: 200\n"
            "    debug_on: false\n"
            "  }\n"
            "}\n";

        // 根据构建的config写文件
        FILE* writeFp = fopen(configFile.c_str(), "w");
        if (writeFp == nullptr) {
            const int bufSize = 256;
            char buf[bufSize] = { 0 };
            strerror_r(errno, buf, bufSize);
            PROFILER_LOG_ERROR(LOG_CORE, "CreateConfigFile: fopen() error = %s", buf);
            return;
        }

        size_t len = fwrite(const_cast<char*>(configStr.c_str()), 1, configStr.length(), writeFp);
        if (len < 0) {
            const int bufSize = 256;
            char buf[bufSize] = { 0 };
            strerror_r(errno, buf, bufSize);
            PROFILER_LOG_ERROR(LOG_CORE, "CreateConfigFile: fwrite() error = %s", buf);
            if (fclose(writeFp) != 0) {
                PROFILER_LOG_ERROR(LOG_CORE, "fclose() error");
            }
            return;
        }

        int ret = fflush(writeFp);
        if (ret == EOF) {
            const int bufSize = 256;
            char buf[bufSize] = { 0 };
            strerror_r(errno, buf, bufSize);
            PROFILER_LOG_ERROR(LOG_CORE, "CreateConfigFile: fflush() error = %s", buf);
            if (fclose(writeFp) != 0) {
                PROFILER_LOG_ERROR(LOG_CORE, "fclose() error");
            }
            return;
        }

        fsync(fileno(writeFp));
        ret = fclose(writeFp);
        if (ret != 0) {
            const int bufSize = 256;
            char buf[bufSize] = { 0 };
            strerror_r(errno, buf, bufSize);
            PROFILER_LOG_ERROR(LOG_CORE, "CreateConfigFile: fclose() error = %s", buf);
            return;
        }
    }

    std::string CreateCommand(const std::string &outFile, int time) const
    {
        std::string cmdStr =
            "hiprofiler_cmd \\\n"
            "-c - \\\n";
        cmdStr += "-o " + outFile + " \\\n";
        cmdStr += "-t " + std::to_string(time) + " \\\n";
        cmdStr += "-k \\\n"
            "<<CONFIG\n"
            "request_id: 1\n"
            "session_config {\n"
            "  buffers {\n"
            "    pages: 1000\n"
            "  }\n"
            "  result_file: \"/data/local/tmp/hiprofiler_data.htrace\"\n"
            "  sample_duration: 1000\n"
            "}\n"
            "plugin_configs {\n"
            "  plugin_name: \"ftrace-plugin\"\n"
            "  sample_interval: 1000\n"
            "  is_protobuf_serialize: true\n"
            "  config_data {\n"
            "    ftrace_events: \"sched/sched_switch\"\n"
            "    ftrace_events: \"sched/sched_wakeup\"\n"
            "    ftrace_events: \"sched/sched_wakeup_new\"\n"
            "    ftrace_events: \"sched/sched_waking\"\n"
            "    ftrace_events: \"sched/sched_process_exit\"\n"
            "    ftrace_events: \"sched/sched_process_free\"\n"
            "    hitrace_categories: \"ability\"\n"
            "    hitrace_categories: \"ace\"\n"
            "    buffer_size_kb: 51200\n"
            "    flush_interval_ms: 1000\n"
            "    flush_threshold_kb: 4096\n"
            "    parse_ksyms: true\n"
            "    clock: \"mono\"\n"
            "    trace_period_ms: 200\n"
            "    debug_on: false\n"
            "  }\n"
            "}\n"
            "CONFIG\n";
        return cmdStr;
    }

    std::string CreateHiperfCommand(const std::string &outFile, int time) const
    {
        std::string cmdStr =
            "hiprofiler_cmd \\\n"
            "-c - \\\n";
        cmdStr += "-o " + outFile + " \\\n";
        cmdStr += "-t " + std::to_string(time) + " \\\n";
        cmdStr += "-k \\\n"
            "<<CONFIG\n"
            "request_id: 1\n"
            "session_config {\n"
            "  buffers {\n"
            "    pages: 1000\n"
            "  }\n"
            "  result_file: \"/data/local/tmp/hiprofiler_data.htrace\"\n"
            "  sample_duration: 1000\n"
            "}\n"
            "plugin_configs {\n"
            "  plugin_name: \"hiperf-plugin\"\n"
            "  sample_interval: 1000\n"
            "  is_protobuf_serialize: true\n"
            "  config_data {\n"
            "    is_root: false\n"
            "    outfile_name: \"/data/local/tmp/perf.data\"\n"
            "    record_args: \"-f 1000 -a --call-stack dwarf\"\n"
            "  }\n"
            "}\n"
            "CONFIG\n";
        return cmdStr;
    }

    std::string CreateEncoderCommand(const std::string &outFile, int time) const
    {
        std::string cmdStr =
            "hiprofiler_cmd \\\n"
            "-c - \\\n";
        cmdStr += "-k \\\n";
        cmdStr += "-o " + outFile + " \\\n";
        cmdStr += "-t " + std::to_string(time) + " \\\n"
            "<<CONFIG\n"
            "request_id: 1\n"
            "session_config {\n"
            "  buffers {\n"
            "    pages: 1000\n"
            "  }\n"
            "  result_file: \"/data/local/tmp/hiprofiler_data.htrace\"\n"
            "  sample_duration: 3000\n"
            "}\n"
            "plugin_configs {\n"
            "  plugin_name: \"ftrace-plugin\"\n"
            "  sample_interval: 1000\n"
            "  config_data {\n"
            "    ftrace_events: \"sched/sched_switch\"\n"
            "    ftrace_events: \"sched/sched_wakeup\"\n"
            "    ftrace_events: \"sched/sched_wakeup_new\"\n"
            "    ftrace_events: \"sched/sched_waking\"\n"
            "    ftrace_events: \"sched/sched_process_exit\"\n"
            "    ftrace_events: \"sched/sched_process_free\"\n"
            "    hitrace_categories: \"ability\"\n"
            "    hitrace_categories: \"ace\"\n"
            "    buffer_size_kb: 51200\n"
            "    flush_interval_ms: 1000\n"
            "    flush_threshold_kb: 4096\n"
            "    parse_ksyms: true\n"
            "    clock: \"mono\"\n"
            "    trace_period_ms: 200\n"
            "    debug_on: false\n"
            "  }\n"
            "}\n"
            "CONFIG\n";
        return cmdStr;
    }

    std::string CreateSplitHtraceCommand(const std::string &outFile, int time) const
    {
        std::string cmdStr =
            "hiprofiler_cmd -s -k \\\n"
            "-c - \\\n";
        cmdStr += "-o " + outFile + " \\\n";
        cmdStr += "-t " + std::to_string(time) + " \\\n"
            "<<CONFIG\n"
            "request_id: 1\n"
            "session_config {\n"
            "  buffers {\n"
            "    pages: 16384\n"
            "  }\n"
            "  split_file: true\n"
            "}\n"
            "plugin_configs {\n"
            "  plugin_name: \"ftrace-plugin\"\n"
            "  sample_interval: 1000\n"
            "  config_data {\n"
            "    ftrace_events: \"sched/sched_switch\"\n"
            "    ftrace_events: \"sched/sched_wakeup\"\n"
            "    ftrace_events: \"sched/sched_wakeup_new\"\n"
            "    ftrace_events: \"sched/sched_waking\"\n"
            "    ftrace_events: \"sched/sched_process_exit\"\n"
            "    ftrace_events: \"sched/sched_process_free\"\n"
            "    buffer_size_kb: 51200\n"
            "    flush_interval_ms: 1000\n"
            "    flush_threshold_kb: 4096\n"
            "    parse_ksyms: true\n"
            "    clock: \"mono\"\n"
            "    trace_period_ms: 200\n"
            "    debug_on: false\n"
            "  }\n"
            "}\n"
            "CONFIG\n";
        return cmdStr;
    }

    std::string CreateSplitHiperfCommand(const std::string &outFile, const std::string &perfFile,
                                    const std::string &perfSplitFile, int time) const
    {
        std::string cmdStr =
            "hiprofiler_cmd -s -k \\\n"
            "-c - \\\n";
        cmdStr += "-o " + outFile + " \\\n";
        cmdStr += "-t " + std::to_string(time) + " \\\n"
            "<<CONFIG\n"
            "request_id: 1\n"
            "session_config {\n"
            "  buffers {\n"
            "    pages: 16384\n"
            "  }\n"
            "  split_file: true\n"
            "}\n"
            "plugin_configs {\n"
            "  plugin_name: \"hiperf-plugin\"\n"
            "  config_data {\n"
            "    is_root: false\n"
            "    outfile_name: \"" + perfFile + "\"\n"
            "    record_args: \"-f 1000 -a  --cpu-limit 100 -e hw-cpu-cycles,sched:sched_waking --call-stack dwarf --clockid monotonic --offcpu -m 256\"\n"
            "    split_outfile_name: \"" + perfSplitFile + "\"\n"
            "  }\n"
            "}\n"
            "CONFIG\n";
        return cmdStr;
    }

    std::string CreateSplitHiebpfCommand(const std::string &outFile, const std::string &ebpfFile,
                                            const std::string &ebpfSplitFile, int time) const
    {
        std::string cmdStr =
            "hiprofiler_cmd -s -k \\\n"
            "-c - \\\n";
        cmdStr += "-o " + outFile + " \\\n";
        cmdStr += "-t " + std::to_string(time) + " \\\n"
            "<<CONFIG\n"
            "request_id: 1\n"
            "session_config {\n"
            "  buffers {\n"
            "    pages: 16384\n"
            "  }\n"
            "  split_file: true\n"
            "}\n"
            "plugin_configs {\n"
            "  plugin_name: \"hiebpf-plugin\"\n"
            "  config_data {\n"
            "    cmd_line: \"hiebpf --events fs,ptrace,bio --duration 200 --max_stack_depth 10\"\n"
            "    outfile_name: \"" + ebpfFile + "\"\n"
            "    split_outfile_name: \"" + ebpfSplitFile + "\"\n"
            "  }\n"
            "}\n"
            "CONFIG\n";
        return cmdStr;
    }

    unsigned long GetFileSize(const char* filename)
    {
        struct stat buf;

        if (stat(filename, &buf) < 0) {
            return 0;
        }
        return static_cast<unsigned long>(buf.st_size);
    }

    void KillProcess(const std::string processName)
    {
        int pid = -1;
        std::string findpid = "pidof " + processName;
        PROFILER_LOG_INFO(LOG_CORE, "find pid command : %s", findpid.c_str());
        std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(findpid.c_str(), "r"), pclose);

        char line[LINE_SIZE];
        do {
            if (fgets(line, sizeof(line), pipe.get()) == nullptr) {
                PROFILER_LOG_INFO(LOG_CORE, "not find processName : %s", processName.c_str());
                return;
            } else if (strlen(line) > 0 && isdigit(static_cast<unsigned char>(line[0]))) {
                pid = atoi(line);
                PROFILER_LOG_INFO(LOG_CORE, "find processName : %s, pid: %d", processName.c_str(), pid);
                break;
            }
        } while (1);

        if (pid != -1) {
            StopProcessStub(pid);
        }
    }
private:
    int hiprofilerdPid_ = -1;
    int hiprofilerPluginsPid_ = -1;
};

/**
 * @tc.name: hiprofiler_cmd
 * @tc.desc: Test hiprofiler_cmd with -h -q.
 * @tc.type: FUNC
 */
HWTEST_F(HiprofilerCmdTest, DFX_DFR_Hiprofiler_0110, Function | MediumTest | Level1)
{
    KillProcess(DEFAULT_HIPROFILERD_NAME);
    KillProcess(DEFAULT_HIPROFILER_PLUGINS_NAME);

    std::string cmd = DEFAULT_HIPROFILER_CMD_PATH + " -h";
    std::string content = "";
    EXPECT_TRUE(RunCommand(cmd, content));
    std::string destStr = "help";
    EXPECT_EQ(strncmp(content.c_str(), destStr.c_str(), strlen(destStr.c_str())), 0);

    content = "";
    cmd = DEFAULT_HIPROFILER_CMD_PATH + " -q";
    EXPECT_TRUE(RunCommand(cmd, content));
    destStr = "Service not started";
    EXPECT_EQ(strncmp(content.c_str(), destStr.c_str(), strlen(destStr.c_str())), 0);

    StartServerStub(DEFAULT_HIPROFILERD_PATH);
    sleep(1);
    content = "";
    EXPECT_TRUE(RunCommand(cmd, content));
    destStr = "OK";
    EXPECT_EQ(strncmp(content.c_str(), destStr.c_str(), strlen(destStr.c_str())), 0);
    StopProcessStub(hiprofilerdPid_);
}

/**
 * @tc.name: hiprofiler_cmd
 * @tc.desc: Test hiprofiler_cmd with -c file.
 * @tc.type: FUNC
 */
HWTEST_F(HiprofilerCmdTest, DFX_DFR_Hiprofiler_0120, Function | MediumTest | Level1)
{
    KillProcess(DEFAULT_HIPROFILERD_NAME);
    KillProcess(DEFAULT_HIPROFILER_PLUGINS_NAME);

    // 测试不存在的config文件
    std::string configTestFile = DEFAULT_PATH + "1234.txt";
    std::string outFile = DEFAULT_PATH + "trace.htrace";
    std::string content = "";
    std::string cmd = DEFAULT_HIPROFILER_CMD_PATH + " -c " + configTestFile + " -o " + outFile + " -t 3";
    EXPECT_TRUE(RunCommand(cmd, content));
    std::string destStr = "Read " + configTestFile + " fail";
    EXPECT_TRUE(content.find(destStr) != std::string::npos);

    // 创建有效的config文件
    const std::string configFile = DEFAULT_PATH + "ftrace.config";
    CreateConfigFile(configFile);

    // 测试有效的config文件，不开启hiprofilerd和hiprofiler_plugin进程
    content = "";
    cmd = DEFAULT_HIPROFILER_CMD_PATH + " -c " + configFile + " -o " + outFile + " -t 3";
    EXPECT_TRUE(RunCommand(cmd, content));
    sleep(SLEEP_TIME);
    EXPECT_NE(access(outFile.c_str(), F_OK), 0);

    // 开启hiprofilerd和hiprofiler_plugin进程，可以生成trace文件
    content = "";
    StartServerStub(DEFAULT_HIPROFILERD_PATH);
    sleep(1);
    StartServerStub(DEFAULT_HIPROFILER_PLUGINS_PATH);
    sleep(1);
    EXPECT_TRUE(RunCommand(cmd, content));
    sleep(SLEEP_TIME);
    EXPECT_EQ(access(outFile.c_str(), F_OK), 0);

    // 删除资源文件和生成的trace文件
    cmd = "rm " + configFile + " " + outFile;
    system(cmd.c_str());
    StopProcessStub(hiprofilerPluginsPid_);
    StopProcessStub(hiprofilerdPid_);
}

/**
 * @tc.name: hiprofiler_cmd
 * @tc.desc: Test hiprofiler_cmd with -c string.
 * @tc.type: FUNC
 */
HWTEST_F(HiprofilerCmdTest, DFX_DFR_Hiprofiler_0130, Function | MediumTest | Level1)
{
    std::string cmd = "cp " + DEFAULT_SO_PATH + "libftrace_plugin.z.so " + DEFAULT_PATH;
    system(cmd.c_str());

    // 开启hiprofilerd和hiprofiler_plugin进程，验证字符串格式的config
    std::string content = "";
    StartServerStub(DEFAULT_HIPROFILERD_PATH);
    sleep(1);
    StartServerStub(DEFAULT_HIPROFILER_PLUGINS_PATH);
    sleep(1);
    std::string outFile = DEFAULT_PATH + "trace.htrace";
    int time = 3;
    cmd = CreateCommand(outFile, time);
    EXPECT_TRUE(RunCommand(cmd, content));
    sleep(time);
    EXPECT_EQ(access(outFile.c_str(), F_OK), 0);

    // 删除资源文件和生成的trace文件
    cmd = "rm " + FTRACE_PLUGIN_PATH + " " + outFile;
    system(cmd.c_str());
    StopProcessStub(hiprofilerPluginsPid_);
    StopProcessStub(hiprofilerdPid_);
}

/**
 * @tc.name: hiprofiler_cmd
 * @tc.desc: Test hiprofiler_cmd with -s -l -k.
 * @tc.type: FUNC
 */
HWTEST_F(HiprofilerCmdTest, DFX_DFR_Hiprofiler_0140, Function | MediumTest | Level1)
{
    KillProcess(DEFAULT_HIPROFILERD_NAME);
    KillProcess(DEFAULT_HIPROFILER_PLUGINS_NAME);

    std::string cmd = DEFAULT_HIPROFILER_CMD_PATH + " -s -l -k";
    std::string content = "";
    EXPECT_TRUE(RunCommand(cmd, content));
    std::string destStr = "plugin";
    EXPECT_TRUE(content.find(destStr) != std::string::npos);
}

/**
 * @tc.name: hiprofiler_cmd
 * @tc.desc: Test hiprofiler_cmd with -l -k.
 * @tc.type: FUNC
 */
HWTEST_F(HiprofilerCmdTest, DFX_DFR_Hiprofiler_0150, Function | MediumTest | Level1)
{
    KillProcess(DEFAULT_HIPROFILERD_NAME);
    KillProcess(DEFAULT_HIPROFILER_PLUGINS_NAME);

    std::string cmd = DEFAULT_HIPROFILER_CMD_PATH + " -l -k";
    std::string content = "";
    EXPECT_TRUE(RunCommand(cmd, content));
}

/**
 * @tc.name: hiprofiler_cmd
 * @tc.desc: Test hiprofiler_cmd with -k.
 * @tc.type: FUNC
 */
HWTEST_F(HiprofilerCmdTest, DFX_DFR_Hiprofiler_0160, Function | MediumTest | Level1)
{
    KillProcess(DEFAULT_HIPROFILERD_NAME);
    KillProcess(DEFAULT_HIPROFILER_PLUGINS_NAME);

    std::string cmd = DEFAULT_HIPROFILER_CMD_PATH + " -k";
    std::string content = "";
    EXPECT_TRUE(RunCommand(cmd, content));
}

/**
 * @tc.name: hiprofiler_cmd
 * @tc.desc: Test hiprofiler_cmd with proto encoder.
 * @tc.type: FUNC
 */
HWTEST_F(HiprofilerCmdTest, DFX_DFR_Hiprofiler_0170, Function | MediumTest | Level1)
{
    std::string cmd = "cp " + DEFAULT_SO_PATH + "libftrace_plugin.z.so " + DEFAULT_PATH;
    system(cmd.c_str());

    // 开启hiprofilerd和hiprofiler_plugin进程，验证字符串格式的config
    std::string content = "";
    StartServerStub(DEFAULT_HIPROFILERD_PATH);
    sleep(1);
    StartServerStub(DEFAULT_HIPROFILER_PLUGINS_PATH);
    sleep(1);
    std::string outFile = DEFAULT_PATH + "trace_encoder.htrace";
    int time = 3;
    cmd = CreateEncoderCommand(outFile, time);
    EXPECT_TRUE(RunCommand(cmd, content));
    sleep(time);
    EXPECT_EQ(access(outFile.c_str(), F_OK), 0);

    // 删除资源文件和生成的trace文件
    cmd = "rm " + FTRACE_PLUGIN_PATH + " " + outFile;
    system(cmd.c_str());
    StopProcessStub(hiprofilerPluginsPid_);
    StopProcessStub(hiprofilerdPid_);
}

/**
 * @tc.name: hiprofiler_cmd
 * @tc.desc: Test hiprofiler_cmd with ctrl+c.
 * @tc.type: FUNC
 */
HWTEST_F(HiprofilerCmdTest, DFX_DFR_Hiprofiler_0180, Function | MediumTest | Level1)
{
    std::string content = "";
    std::string cmd = DEFAULT_HIPROFILER_CMD_PATH + " -s";
    EXPECT_TRUE(RunCommand(cmd, content));
    sleep(2); // 2: wait hiprofilerd start
    pid_t pid = fork();
    EXPECT_GE(pid, 0);
    if (pid == 0) {
        content = "";
        const int time = 20;
        std::string outFile = DEFAULT_PATH + "trace.htrace";
        cmd = CreateCommand(outFile, time);
        EXPECT_TRUE(RunCommand(cmd, content));
        EXPECT_EQ(access(outFile.c_str(), F_OK), 0);
        // 删除生成的trace文件
        cmd = "rm " + outFile;
        system(cmd.c_str());
        _exit(0);
    } else if (pid > 0) {
        sleep(1); // 1: wait child process start
        content = "";
        cmd = "pidof hiprofiler_cmd";
        EXPECT_TRUE(RunCommand(cmd, content));
        ASSERT_STRNE(content.c_str(), "");
        cmd = "kill -2 " + content;
        content = "";
        EXPECT_TRUE(RunCommand(cmd, content));
        EXPECT_STREQ(content.c_str(), "");
        // 等待子进程结束
        waitpid(pid, nullptr, 0);
        cmd = DEFAULT_HIPROFILER_CMD_PATH + " -k";
        EXPECT_TRUE(RunCommand(cmd, content));
        sleep(5); // 5: wait hiprofilerd exit
        content = "";
        cmd = "pidof " + DEFAULT_HIPROFILERD_NAME;
        EXPECT_TRUE(RunCommand(cmd, content));
        EXPECT_STREQ(content.c_str(), "");
    }
}

/**
 * @tc.name: hiprofiler_cmd
 * @tc.desc: Test hiprofiler_cmd with -c string.
 * @tc.type: FUNC
 */
HWTEST_F(HiprofilerCmdTest, DFX_DFR_Hiprofiler_0190, Function | MediumTest | Level1)
{
    std::string cmd = "cp " + DEFAULT_SO_PATH + "libhiperfplugin.z.so " + DEFAULT_PATH;
    system(cmd.c_str());

    // 开启hiprofilerd和hiprofiler_plugin进程，验证字符串格式的config
    std::string content = "";
    StartServerStub(DEFAULT_HIPROFILERD_PATH);
    sleep(1);
    StartServerStub(DEFAULT_HIPROFILER_PLUGINS_PATH);
    sleep(1);
    std::string outFile = DEFAULT_PATH + "trace.htrace";
    int time = 10;
    cmd = CreateHiperfCommand(outFile, time);
    EXPECT_TRUE(RunCommand(cmd, content));
    sleep(time);
    EXPECT_EQ(access(outFile.c_str(), F_OK), 0);

    // 删除资源文件和生成的trace文件
    cmd = "rm " + HIPERF_PLUGIN_PATH + " " + outFile;
    system(cmd.c_str());
    StopProcessStub(hiprofilerPluginsPid_);
    StopProcessStub(hiprofilerdPid_);
}
}

/**
 * @tc.name: hiprofiler_cmd
 * @tc.desc: Test hiprofiler_cmd with split Htrace file.
 * @tc.type: FUNC
 */
HWTEST_F(HiprofilerCmdTest, DFX_DFR_Hiprofiler_0200, Function | MediumTest | Level1)
{
    std::string outFileName = "split_htrace";
    std::string outFile = DEFAULT_PATH + outFileName + ".htrace";
    std::string content = "";
    int time = 10;
    std::string cmd = CreateSplitHtraceCommand(outFile, time);
    EXPECT_TRUE(RunCommand(cmd, content));

    EXPECT_NE(access(outFile.c_str(), F_OK), 0);

    cmd = "ls " + DEFAULT_PATH + outFileName + "*_1.htrace";
    EXPECT_TRUE(RunCommand(cmd, content));
    EXPECT_STRNE(content.c_str(), "");

    cmd = "rm " + DEFAULT_PATH + outFileName + "*.htrace";
    system(cmd.c_str());
}

/**
 * @tc.name: hiprofiler_cmd
 * @tc.desc: Test hiprofiler_cmd with split hiperf file.
 * @tc.type: FUNC
 */
HWTEST_F(HiprofilerCmdTest, DFX_DFR_Hiprofiler_0220, Function | MediumTest | Level1)
{
    std::string outFileName = "split_hiperf";
    std::string outFile = DEFAULT_PATH + outFileName + ".htrace";
    std::string perfFile = "/data/local/tmp/perf.data";
    std::string perfSplitFile = "/data/local/tmp/split_perf_data.htrace";
    std::string content = "";
    int time = 10;
    std::string cmd = CreateSplitHiperfCommand(outFile, perfFile, perfSplitFile, time);
    EXPECT_TRUE(RunCommand(cmd, content));

    EXPECT_NE(access(outFile.c_str(), F_OK), 0);

    cmd = "ls " + DEFAULT_PATH + outFileName + "*_1.htrace";
    EXPECT_TRUE(RunCommand(cmd, content));
    EXPECT_STRNE(content.c_str(), "");

    EXPECT_EQ(access(perfSplitFile.c_str(), F_OK), 0);
    if (access(perfFile.c_str(), F_OK) == 0) {
        const int headerSize = 1024 + 1024; // htrace header + hiperf header
        auto perfFileSize = GetFileSize(perfFile.c_str());
        auto perfSplitFileSize = GetFileSize(perfSplitFile.c_str());
        EXPECT_GT(perfSplitFileSize, perfFileSize + headerSize);
    }

    cmd = "rm " + DEFAULT_PATH + outFileName + "*.htrace " + perfFile + " " + perfSplitFile;
    system(cmd.c_str());
}
/**
 * @tc.name: hiprofiler_cmd
 * @tc.desc: Test hiprofiler_cmd with split hiebpf file.
 * @tc.type: FUNC
 */
HWTEST_F(HiprofilerCmdTest, DFX_DFR_Hiprofiler_0230, Function | MediumTest | Level1)
{
#if defined(__LP64__)  // just support 64bit
    std::string outFileName = "split_hiebpf";
    std::string outFile = DEFAULT_PATH + outFileName + ".htrace";
    std::string ebpfFile = "/data/local/tmp/ebpf.data";
    std::string ebpfSplitFile = "/data/local/tmp/split_ebpf_data.htrace";
    std::string content = "";
    int time = 10;
    std::string cmd = CreateSplitHiebpfCommand(outFile, ebpfFile, ebpfSplitFile, time);
    EXPECT_TRUE(RunCommand(cmd, content));

    EXPECT_NE(access(outFile.c_str(), F_OK), 0);

    cmd = "ls " + DEFAULT_PATH + outFileName + "*_1.htrace";
    EXPECT_TRUE(RunCommand(cmd, content));
    EXPECT_STRNE(content.c_str(), "");

    EXPECT_EQ(access(ebpfSplitFile.c_str(), F_OK), 0);
    if (access(ebpfFile.c_str(), F_OK) == 0) {
        const int headerSize = 1024 + 1024; // htrace header + hiebpf header
        auto ebpfFileSize = GetFileSize(ebpfFile.c_str());
        auto ebpfSplitFileSize = GetFileSize(ebpfSplitFile.c_str());
        EXPECT_GT(ebpfSplitFileSize, ebpfFileSize + headerSize);
    }

    cmd = "rm " + DEFAULT_PATH + outFileName + "*.htrace " + ebpfFile + " " + ebpfSplitFile;
    system(cmd.c_str());
#endif
}