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 "hilog_utils_test.h"
16 #include "hilog_common.h"
17 #include <log_utils.h>
18 #include <hilog/log_c.h>
19 #include <list>
20
21 using namespace std;
22 using namespace testing::ext;
23 using namespace OHOS;
24 using namespace OHOS::HiviewDFX;
25
GetCmdResultFromPopen(const std::string & cmd)26 static std::string GetCmdResultFromPopen(const std::string& cmd)
27 {
28 if (cmd.empty()) {
29 return "";
30 }
31 FILE* fp = popen(cmd.c_str(), "r");
32 if (fp == nullptr) {
33 return "";
34 }
35 std::string ret = "";
36 char* buffer = nullptr;
37 size_t len = 0;
38 while (getline(&buffer, &len, fp) != -1) {
39 std::string line = buffer;
40 ret += line;
41 }
42 if (buffer != nullptr) {
43 free(buffer);
44 buffer = nullptr;
45 }
46 pclose(fp);
47 return ret;
48 }
49
50 namespace {
51 /**
52 * @tc.name: Dfx_HilogUtilsTest_HilogUtilsTest_001
53 * @tc.desc: Size2Str & Str2Size.
54 * @tc.type: FUNC
55 */
56 HWTEST_F(HilogUtilsTest, HilogUtilsTest_001, TestSize.Level1)
57 {
58 GTEST_LOG_(INFO) << "HilogUtilsTest_001: start.";
59 const std::list<pair<uint64_t, string>> sizeStrList = {
60 /* size, unit */
61 {1, "B"},
62 {1ULL << 10, "K"},
63 {1ULL << 20, "M"},
64 {1ULL << 30, "G"},
65 {1ULL << 40, "T"},
66 };
67 for (auto &it : sizeStrList) {
68 EXPECT_EQ(Size2Str(it.first), "1.0" + it.second);
69 EXPECT_EQ(Str2Size("1" + it.second), it.first);
70 }
71
72 // valid str reg [0-9]+[BKMGT]?
73 EXPECT_EQ(Str2Size("1.2A"), 0);
74 }
75
76 /**
77 * @tc.name: Dfx_HilogUtilsTest_HilogUtilsTest_002
78 * @tc.desc: LogType2Str & Str2LogType.
79 * @tc.type: FUNC
80 */
81 HWTEST_F(HilogUtilsTest, HilogUtilsTest_002, TestSize.Level1)
82 {
83 GTEST_LOG_(INFO) << "HilogUtilsTest_002: start.";
84 const std::list<pair<LogType, string>> logTypesList = {
85 {LOG_INIT, "init"},
86 {LOG_CORE, "core"},
87 {LOG_APP, "app"},
88 {LOG_KMSG, "kmsg"},
89 {LOG_ONLY_PRERELEASE, "only_prerelease"},
90 {LOG_TYPE_MAX, "invalid"},
91 };
92 for (auto &it : logTypesList) {
93 EXPECT_EQ(LogType2Str(it.first), it.second);
94 EXPECT_EQ(Str2LogType(it.second), it.first);
95 }
96 }
97
98 /**
99 * @tc.name: Dfx_HilogUtilsTest_HilogUtilsTest_003
100 * @tc.desc: ComboLogType2Str & Str2ComboLogType.
101 * @tc.type: FUNC
102 */
103 HWTEST_F(HilogUtilsTest, HilogUtilsTest_003, TestSize.Level1)
104 {
105 GTEST_LOG_(INFO) << "HilogUtilsTest_003: start.";
106 const std::list<pair<uint16_t, string>> logTypesList = {
107 /* ComboLogType, str */
108 {1 << LOG_APP, "app"},
109 {1 << LOG_INIT, "init"},
110 {1 << LOG_CORE, "core"},
111 {1 << LOG_ONLY_PRERELEASE, "only_prerelease"},
112 {1 << LOG_KMSG, "kmsg"},
113 {(1 << LOG_APP) + (1 << LOG_INIT) + (1 << LOG_CORE) + (1 << LOG_ONLY_PRERELEASE) + (1 << LOG_KMSG),
114 "init,core,app,only_prerelease,kmsg"},
115 };
116 for (auto &it : logTypesList) {
117 EXPECT_EQ(ComboLogType2Str(it.first), it.second);
118 EXPECT_EQ(Str2ComboLogType(it.second), it.first);
119 }
120
121 EXPECT_EQ(Str2ComboLogType(""), (1 << LOG_APP) + (1 << LOG_CORE) + (1 << LOG_ONLY_PRERELEASE));
122 EXPECT_EQ(Str2ComboLogType("invalid"), 0);
123 }
124
125 /**
126 * @tc.name: Dfx_HilogUtilsTest_HilogUtilsTest_004
127 * @tc.desc: LogLevel2Str & Str2LogLevel.
128 * @tc.type: FUNC
129 */
130 HWTEST_F(HilogUtilsTest, HilogUtilsTest_004, TestSize.Level1)
131 {
132 GTEST_LOG_(INFO) << "HilogUtilsTest_004: start.";
133 struct LogLevelEntry {
134 const LogLevel logLevel;
135 const std::string str;
136 const std::string shortStr;
137 const int comboLogLevel;
138 };
139
140 LogLevelEntry logLevelEntries[] = {
141 {LOG_LEVEL_MIN, "INVALID", "V", 0},
142 {LOG_DEBUG, "DEBUG", "D", 1 << LOG_DEBUG},
143 {LOG_INFO, "INFO", "I", 1 << LOG_INFO},
144 {LOG_WARN, "WARN", "W", 1 << LOG_WARN},
145 {LOG_ERROR, "ERROR", "E", 1 << LOG_ERROR},
146 {LOG_FATAL, "FATAL", "F", 1 << LOG_FATAL, },
147 {LOG_LEVEL_MAX, "X", "X", 0},
148 };
149
150 constexpr int logLevelEntryCnt = sizeof(logLevelEntries) / sizeof(LogLevelEntry);
151
152 for (int i = 0; i < logLevelEntryCnt; i++) {
153 EXPECT_EQ(LogLevel2Str(logLevelEntries[i].logLevel), logLevelEntries[i].str);
154 EXPECT_EQ(Str2LogLevel(logLevelEntries[i].str), logLevelEntries[i].logLevel);
155 EXPECT_EQ(LogLevel2ShortStr(logLevelEntries[i].logLevel), logLevelEntries[i].shortStr);
156 EXPECT_EQ(ShortStr2LogLevel(logLevelEntries[i].shortStr), logLevelEntries[i].logLevel);
157 if (logLevelEntries[i].comboLogLevel != 0) {
158 EXPECT_EQ(ComboLogLevel2Str(logLevelEntries[i].comboLogLevel), logLevelEntries[i].str);
159 }
160 EXPECT_EQ(Str2ComboLogLevel(logLevelEntries[i].str), logLevelEntries[i].comboLogLevel);
161 }
162
163 EXPECT_EQ(Str2ComboLogLevel(""), 0xFFFF);
164 }
165
166 /**
167 * @tc.name: Dfx_HilogUtilsTest_HilogUtilsTest_005
168 * @tc.desc: GetBitsCount & GetBitPos.
169 * @tc.type: FUNC
170 */
171 HWTEST_F(HilogUtilsTest, HilogUtilsTest_005, TestSize.Level1)
172 {
173 GTEST_LOG_(INFO) << "HelperTest_005: start.";
174 uint64_t num1 = 1 << 4;
175 uint64_t num2 = (1 << 2) + (1 << 3) + (1 << 4);
176 EXPECT_EQ(GetBitPos(num1), 4);
177 // only accpet the number which is power of 2
178 EXPECT_EQ(GetBitPos(num2), 0);
179 EXPECT_EQ(GetBitsCount(num2), 3);
180 }
181
182 /**
183 * @tc.name: Dfx_HilogUtilsTest_HilogUtilsTest_006
184 * @tc.desc: Uint2DecStr DecStr2Uint Uint2HexStr & HexStr2Uint.
185 * @tc.type: FUNC
186 */
187 HWTEST_F(HilogUtilsTest, HilogUtilsTest_006, TestSize.Level1)
188 {
189 GTEST_LOG_(INFO) << "HilogUtilsTest_006: start.";
190 uint32_t decNum = 1250;
191 uint32_t hexNum = 0xd002d00;
192 std::string decStr = "1250";
193 std::string hexStr = "d002d00";
194 EXPECT_EQ(Uint2DecStr(decNum), decStr);
195 EXPECT_EQ(DecStr2Uint(decStr), decNum);
196 EXPECT_EQ(Uint2HexStr(hexNum), hexStr);
197 EXPECT_EQ(HexStr2Uint(hexStr), hexNum);
198 }
199
200 /**
201 * @tc.name: Dfx_HilogUtilsTest_HilogUtilsTest_007
202 * @tc.desc: GetAllLogTypes.
203 * @tc.type: FUNC
204 */
205 HWTEST_F(HilogUtilsTest, HilogUtilsTest_007, TestSize.Level1)
206 {
207 GTEST_LOG_(INFO) << "HilogUtilsTest_007: start.";
208 vector<uint16_t> vec = GetAllLogTypes();
209 sort(vec.begin(), vec.end());
210 vector<uint16_t> allTypes {0, 1, 3, 4, 5};
211 EXPECT_TRUE(vec == allTypes);
212 }
213
214 /**
215 * @tc.name: Dfx_HilogUtilsTest_HilogUtilsTest_008
216 * @tc.desc: GetPPidByPid.
217 * @tc.type: FUNC
218 */
219 HWTEST_F(HilogUtilsTest, HilogUtilsTest_008, TestSize.Level1)
220 {
221 GTEST_LOG_(INFO) << "HilogUtilsTest_008: start.";
222 uint32_t pid = stoi(GetCmdResultFromPopen("pidof hilogd"));
223 EXPECT_EQ(GetPPidByPid(pid), 1);
224
225 uint32_t invalidPid = 999999;
226 EXPECT_EQ(GetPPidByPid(invalidPid), 0);
227 }
228
229 /**
230 * @tc.name: Dfx_HilogUtilsTest_HilogUtilsTest_009
231 * @tc.desc: WaitingToDo.
232 * @tc.type: FUNC
233 */
234 HWTEST_F(HilogUtilsTest, HilogUtilsTest_009, TestSize.Level1)
235 {
236 GTEST_LOG_(INFO) << "HilogUtilsTest_009: start.";
__anon57d8e1130202(const string &path) 237 int ret = WaitingToDo(WAITING_DATA_MS, "/data/log", [](const string &path) {
238 if (!access(path.c_str(), F_OK)) {
239 return RET_SUCCESS;
240 }
241 return RET_FAIL;
242 });
243 EXPECT_EQ(ret, RET_SUCCESS);
244
__anon57d8e1130302(const string &path) 245 ret = WaitingToDo(WAITING_DATA_MS, "/test/ttt", [](const string &path) {
246 if (!access(path.c_str(), F_OK)) {
247 return RET_SUCCESS;
248 }
249 return RET_FAIL;
250 });
251 PrintErrorno(errno);
252 EXPECT_EQ(ret, RET_FAIL);
253 }
254 } // namespace
255