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 16 #include <chrono> 17 #include <thread> 18 #include <hwext/gtest-ext.h> 19 #include <hwext/gtest-tag.h> 20 #include "common.h" 21 #include "logging.h" 22 23 namespace { 24 using namespace testing::ext; 25 using namespace COMMON; 26 27 class CommonTest : public testing::Test { 28 protected: SetUpTestCase()29 static void SetUpTestCase() {} TearDownTestCase()30 static void TearDownTestCase() {} 31 WriteFile(const std::string & filePath,const std::string & fileContent)32 bool WriteFile(const std::string& filePath, const std::string& fileContent) 33 { 34 FILE* file = fopen(filePath.c_str(), "w"); 35 if (file == nullptr) { 36 std::string errorMsg = GetErrorMsg(); 37 HILOG_ERROR(LOG_CORE, "WriteFile: fopen() fail, %s, %s", filePath.c_str(), errorMsg.c_str()); 38 return false; 39 } 40 41 size_t len = fwrite(const_cast<char*>(fileContent.c_str()), 1, fileContent.length(), file); 42 if (len < 0) { 43 std::string errorMsg = GetErrorMsg(); 44 HILOG_ERROR(LOG_CORE, "WriteFile: fwrite() fail, %s", errorMsg.c_str()); 45 (void)fclose(file); 46 return false; 47 } 48 49 if (fflush(file) == EOF) { 50 std::string errorMsg = GetErrorMsg(); 51 HILOG_ERROR(LOG_CORE, "WriteFile: fflush() error = %s", errorMsg.c_str()); 52 (void)fclose(file); 53 return false; 54 } 55 56 fsync(fileno(file)); 57 if (fclose(file) != 0) { 58 std::string errorMsg = GetErrorMsg(); 59 HILOG_ERROR(LOG_CORE, "CreateConfigFile: fclose() error = %s", errorMsg.c_str()); 60 return false; 61 } 62 return true; 63 } 64 }; 65 66 /** 67 * @tc.name: CommonTest 68 * @tc.desc: IsProcessExist. 69 * @tc.type: FUNC 70 */ 71 HWTEST_F(CommonTest, IsProcessExist, TestSize.Level1) 72 { 73 const std::string procName = "hiprofiler_base_ut"; 74 int pid = 0; 75 EXPECT_TRUE(COMMON::IsProcessExist(procName, pid)); 76 EXPECT_NE(pid, 0); 77 const std::string invalidProcName = "ls"; 78 pid = 0; 79 EXPECT_FALSE(COMMON::IsProcessExist(invalidProcName, pid)); 80 EXPECT_EQ(pid, 0); 81 } 82 83 /** 84 * @tc.name: CommonTest 85 * @tc.desc: StartProcess. 86 * @tc.type: FUNC 87 */ 88 HWTEST_F(CommonTest, StartAndKillProcess, TestSize.Level1) 89 { 90 constexpr int waitProcMills = 300; 91 std::string profilerProcName("hiprofilerd"); 92 std::vector<char*> argvVec; 93 argvVec.push_back(const_cast<char*>(profilerProcName.c_str())); 94 int lockFileFd = -1; 95 EXPECT_FALSE(COMMON::IsProcessRunning(lockFileFd)); 96 int procPid = COMMON::StartProcess(profilerProcName, argvVec); 97 EXPECT_NE(procPid, 0); 98 std::this_thread::sleep_for(std::chrono::milliseconds(waitProcMills)); 99 EXPECT_NE(COMMON::KillProcess(procPid), -1); 100 } 101 102 /** 103 * @tc.name: CommonTest 104 * @tc.desc: VerifyPath. 105 * @tc.type: FUNC 106 */ 107 HWTEST_F(CommonTest, VerifyPath, TestSize.Level1) 108 { 109 std::string filePath = "/data/local/tmp/config.txt"; 110 std::vector<std::string> validPaths = {}; 111 EXPECT_TRUE(VerifyPath(filePath, validPaths)); 112 113 validPaths = { "/tmp/" }; 114 EXPECT_FALSE(VerifyPath(filePath, validPaths)); 115 116 validPaths = { "/tmp/", "/data/" }; 117 EXPECT_TRUE(VerifyPath(filePath, validPaths)); 118 119 validPaths = { "/tmp/", "/data/local/tmp/" }; 120 EXPECT_TRUE(VerifyPath(filePath, validPaths)); 121 122 filePath = "/data/local/tmpconfig.txt"; 123 validPaths = { "/tmp/", "/data/local/tmp/" }; 124 EXPECT_FALSE(VerifyPath(filePath, validPaths)); 125 } 126 127 /** 128 * @tc.name: CommonTest 129 * @tc.desc: ReadFile. 130 * @tc.type: FUNC 131 */ 132 HWTEST_F(CommonTest, ReadFile, TestSize.Level1) 133 { 134 std::string fileName = "/data/local/tmp/config.txt"; 135 std::string fileContent = "Hello world"; 136 EXPECT_TRUE(WriteFile(fileName, fileContent)); 137 138 // invalid path 139 std::vector<std::string> validPaths = { "/tmp/" }; 140 std::string readContent; 141 bool ret = ReadFile(fileName, validPaths, readContent); 142 EXPECT_FALSE(ret); 143 EXPECT_TRUE(readContent.empty()); 144 145 // invalid file path 146 fileName = "config.txt"; 147 validPaths = { "/tmp/", "/data/local/tmp/" }; 148 readContent.clear(); 149 ret = ReadFile(fileName, validPaths, readContent); 150 EXPECT_FALSE(ret); 151 EXPECT_TRUE(readContent.empty()); 152 153 // invalid file name 154 fileName = "configtmp.txt"; 155 validPaths = { "/tmp/", "/data/local/tmp/" }; 156 readContent.clear(); 157 ret = ReadFile(fileName, validPaths, readContent); 158 EXPECT_FALSE(ret); 159 EXPECT_TRUE(readContent.empty()); 160 161 // valid path 162 fileName = "/data/local/tmp/config.txt"; 163 validPaths = { "/tmp/", "/data/local/tmp/" }; 164 readContent.clear(); 165 ret = ReadFile(fileName, validPaths, readContent); 166 EXPECT_TRUE(ret); 167 EXPECT_TRUE(readContent == fileContent); 168 169 // delete file 170 fileName = "/data/local/tmp/config.txt"; 171 std::string cmd = "rm " + fileName; 172 system(cmd.c_str()); 173 } 174 175 /** 176 * @tc.name: CommonTest 177 * @tc.desc: WriteFileFailed. 178 * @tc.type: FUNC 179 */ 180 HWTEST_F(CommonTest, WriteFileFailed, TestSize.Level1) 181 { 182 std::string fileName = "/data/local/tmp/invalid/config.txt"; 183 std::string fileContent = "Hello world"; 184 EXPECT_FALSE(WriteFile(fileName, fileContent)); 185 } 186 187 /** 188 * @tc.name: CommonTest 189 * @tc.desc: GetTimeStr. 190 * @tc.type: FUNC 191 */ 192 HWTEST_F(CommonTest, GetTimeStr, TestSize.Level1) 193 { 194 std::string timeStr = GetTimeStr(); 195 EXPECT_FALSE(timeStr.empty()); 196 } 197 } // namespace