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 "hisysevent_tool_unit_test.h"
17
18 #include <thread>
19 #include <chrono>
20
21 #include "hilog/log.h"
22
23 #include "hisysevent_delegate.h"
24 #include "hisysevent_record.h"
25 #include "hisysevent_tool_listener.h"
26 #include "hisysevent_tool_query.h"
27 #include "hisysevent_tool.h"
28 #include "json_flatten_parser.h"
29
30 using namespace std;
31
32 namespace OHOS {
33 namespace HiviewDFX {
34 namespace {
35 constexpr int ARGV_START_INDEX = 1;
36 constexpr int SLEEP_DURATION = 1000;
GetMilliseconds()37 inline uint64_t GetMilliseconds()
38 {
39 auto now = std::chrono::system_clock::now();
40 auto millisecs = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
41 return millisecs.count();
42 }
43
RunCmds(std::shared_ptr<HiSysEventTool> tool,int argc,char ** argv)44 void RunCmds(std::shared_ptr<HiSysEventTool> tool, int argc, char** argv)
45 {
46 auto ret = tool->ParseCmdLine(argc, argv);
47 ASSERT_TRUE(ret);
48 ret = tool->DoAction();
49 ASSERT_TRUE(ret);
50 thread notifyThread([tool] () {
51 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_DURATION));
52 tool->NotifyClient();
53 });
54 notifyThread.detach();
55 tool->WaitClient();
56 ASSERT_TRUE(true);
57 }
58 }
59
SetUpTestCase()60 void HiSysEventToolUnitTest::SetUpTestCase() {}
61
TearDownTestCase()62 void HiSysEventToolUnitTest::TearDownTestCase() {}
63
SetUp()64 void HiSysEventToolUnitTest::SetUp() {}
65
TearDown()66 void HiSysEventToolUnitTest::TearDown() {}
67
68 /**
69 * @tc.name: HiSysEventToolUnitTest001
70 * @tc.desc: Test APIs of class HiSysEventToolListener
71 * @tc.type: FUNC
72 * @tc.require: issueI66JWR
73 */
74 HWTEST_F(HiSysEventToolUnitTest, HiSysEventToolUnitTest001, testing::ext::TestSize.Level3)
75 {
76 constexpr char origin[] = "{\"domain_\":\"DEMO\",\"name_\":\"EVENT_NAME_A\",\"type_\":4,\
77 \"PARAM_A\":3.4,\"UINT64_T\":18446744073709551610,\"DOUBLE_T\":3.3,\"INT64_T\":9223372036854775800,\
78 \"PARAM_B\":[\"123\", \"456\", \"789\"],\"PARAM_C\":[]}";
79 auto sysEventRecord = std::make_shared<HiSysEventRecord>(origin);
80 HiSysEventToolListener listener1(true);
81 listener1.OnEvent(nullptr);
82 ASSERT_TRUE(true);
83 listener1.OnEvent(sysEventRecord);
84 ASSERT_TRUE(true);
85 HiSysEventToolListener listener2(false);
86 listener2.OnEvent(nullptr);
87 ASSERT_TRUE(true);
88 listener2.OnEvent(sysEventRecord);
89 ASSERT_TRUE(true);
90 }
91
92 /**
93 * @tc.name: HiSysEventToolUnitTest002
94 * @tc.desc: Test APIs of class JsonFlattenParser
95 * @tc.type: FUNC
96 * @tc.require: issueI66JWR
97 */
98 HWTEST_F(HiSysEventToolUnitTest, HiSysEventToolUnitTest002, testing::ext::TestSize.Level3)
99 {
100 constexpr char origin[] = "{\"domain_\":\"DEMO\",\"name_\":\"EVENT_NAME_A\",\"type_\":4,\
101 \"PARAM_A\":3.4,\"UINT64_T\":18446744073709551610,\"DOUBLE_T\":3.3,\"INT64_T\":9223372036854775800,\
102 \"PARAM_B\":[\"123\", \"456\", \"789\"],\"PARAM_C\":[\"A\",\"B\",\"C\"]}";
103 JsonFlattenParser parser(origin);
__anonc00034c30302(auto& kv) 104 auto ret = parser.Print([] (auto& kv) {
105 return kv.first.append(kv.second);
106 });
107 ASSERT_TRUE(ret.find("UINT64_T18446744073709551610") != string::npos);
108 parser.Parse(origin);
__anonc00034c30402(auto& kv) 109 ret = parser.Print([] (auto& kv) {
110 return kv.first.append("|").append(kv.second);
111 });
112 ASSERT_TRUE(ret.find("UINT64_T|18446744073709551610") != string::npos);
113 }
114
115 /**
116 * @tc.name: HiSysEventToolUnitTest003
117 * @tc.desc: Test APIs of class HiSysEventJsonDecorator
118 * @tc.type: FUNC
119 * @tc.require: issueI66JWR
120 */
121 HWTEST_F(HiSysEventToolUnitTest, HiSysEventToolUnitTest003, testing::ext::TestSize.Level3)
122 {
123 constexpr char origin0[] = "{\"domain_\":\"USERIAM_PIN\",}";
124 HiSysEventRecord record0(origin0);
125 HiSysEventJsonDecorator decorator;
126 auto ret = decorator.DecorateEventJsonStr(record0);
127 ASSERT_EQ(std::string(origin0), ret);
128 constexpr char origin1[] = "{\"domain_\":\"HIVIEWDFX\",\"name_\":\"BREAK\",\"type_\":3,"
129 "\"time_\":1502965663170,\"tz_\":\"+0800\",\"pid_\":1710,\"tid_\":1747,"
130 "\"uid_\":20010037,\"UID\":1,\"PID\":1,\"PROCESS_NAME\":\"hiview js test suite\","
131 "\"PACKAGE_NAME\":\"com.test.testHiSysEvent\",\"level_\":\"CRITICAL\","
132 "\"id_\":\"14645518577780955344\",\"info_\":\"\",\"seq_\":357}";
133 HiSysEventRecord record1(origin1);
134 ret = decorator.DecorateEventJsonStr(record1);
135 ASSERT_TRUE(ret.find("\033[31m") != string::npos);
136 constexpr char origin2[] = "{\"domain_\":\"HIVIEWDFX\",\"name_\":\"BREAK\",\"type_\":3,"
137 "\"time_\":1502965663170,\"tz_\":\"+0800\",\"pid_\":1710,\"tid_\":1747,"
138 "\"uid_\":20010037,\"level_\":\"CRITICAL\","
139 "\"id_\":\"14645518577780955344\",\"info_\":\"\"}";
140 HiSysEventRecord record2(origin2);
141 ret = decorator.DecorateEventJsonStr(record2);
142 ASSERT_TRUE(ret.find("\033[31m") == string::npos);
143 constexpr char origin3[] = "{\"domain_\":\"HIVIEWDFX\",\"name_\":\"BREAK\",\"type_\":3,"
144 "\"time_\":1502965663170,\"tz_\":\"+0800\",\"pid_\":1710,\"tid_\":1747,"
145 "\"uid_\":20010037,\"CHANGE_TYPE\":\"hiview js test suite\",\"level_\":\"CRITICAL\","
146 "\"id_\":\"14645518577780955344\",\"info_\":\"\",\"seq_\":357}";
147 HiSysEventRecord record3(origin3);
148 ret = decorator.DecorateEventJsonStr(record3);
149 ASSERT_TRUE(ret.find("\033[31m") != string::npos);
150 }
151
152 /**
153 * @tc.name: HiSysEventToolUnitTest004
154 * @tc.desc: Test APIs of class HiSysEventToolQuery
155 * @tc.type: FUNC
156 * @tc.require: issueI66JWR
157 */
158 HWTEST_F(HiSysEventToolUnitTest, HiSysEventToolUnitTest004, testing::ext::TestSize.Level3)
159 {
160 constexpr char origin[] = "{\"domain_\":\"DEMO\",\"name_\":\"EVENT_NAME_A\",\"type_\":4,\
161 \"PARAM_A\":3.4,\"UINT64_T\":18446744073709551610,\"DOUBLE_T\":3.3,\"INT64_T\":9223372036854775800,\
162 \"PARAM_B\":[\"123\", \"456\", \"789\"],\"PARAM_C\":[]}";
163 HiSysEventRecord sysEventRecord(origin);
164 auto records1 = std::make_shared<std::vector<HiSysEventRecord>>();
165 records1->emplace_back(sysEventRecord);
166 HiSysEventToolQuery query1(true);
167 query1.OnQuery(nullptr);
168 ASSERT_TRUE(true);
169 query1.OnQuery(records1);
170 ASSERT_TRUE(true);
171 HiSysEventToolQuery query2(false, false);
172 query2.OnQuery(nullptr);
173 ASSERT_TRUE(true);
174 query2.OnQuery(records1);
175 ASSERT_TRUE(true);
176 int32_t reason = 0;
177 int32_t count = 10;
178 query2.OnComplete(reason, count);
179 ASSERT_TRUE(true);
180 }
181
182 /**
183 * @tc.name: HiSysEventToolUnitTest005
184 * @tc.desc: Test show help, wait/notify information
185 * @tc.type: FUNC
186 * @tc.require: issueI66JWR
187 */
188 HWTEST_F(HiSysEventToolUnitTest, HiSysEventToolUnitTest005, testing::ext::TestSize.Level3)
189 {
190 auto tool = std::make_shared<HiSysEventTool>(false);
191 tool->DoCmdHelp();
192 ASSERT_TRUE(true);
193 constexpr int argc = 2;
194 const char* argv[] = {
195 "hisysevent",
196 "-h",
197 };
198 optind = ARGV_START_INDEX;
199 auto ret = tool->ParseCmdLine(argc, const_cast<char**>(argv));
200 ASSERT_TRUE(!ret);
201 }
202
203 /**
204 * @tc.name: HiSysEventToolUnitTest006
205 * @tc.desc: Test subscribe hisysevents by tag
206 * @tc.type: FUNC
207 * @tc.require: issueI66JWR
208 */
209 HWTEST_F(HiSysEventToolUnitTest, HiSysEventToolUnitTest006, testing::ext::TestSize.Level3)
210 {
211 auto tool = std::make_shared<HiSysEventTool>(false);
212 constexpr int argc = 7;
213 const char* argv[] = {
214 "hisysevent",
215 "-r",
216 "-c",
217 "WHOLE_WORD",
218 "-t",
219 "TAG1",
220 "-v",
221 };
222 optind = ARGV_START_INDEX;
223 RunCmds(tool, argc, const_cast<char**>(argv));
224 }
225
226 /**
227 * @tc.name: HiSysEventToolUnitTest007
228 * @tc.desc: Test subscribe hisysevents by domain and event name
229 * @tc.type: FUNC
230 * @tc.require: issueI66JWR
231 */
232 HWTEST_F(HiSysEventToolUnitTest, HiSysEventToolUnitTest007, testing::ext::TestSize.Level3)
233 {
234 auto tool = std::make_shared<HiSysEventTool>(false);
235 constexpr int argc = 9;
236 const char* argv[] = {
237 "hisysevent",
238 "-r",
239 "-c",
240 "PREFIX",
241 "-o",
242 "USERIAM_PIN",
243 "-n",
244 "USERIAM_TEMPLATE_CHANGE",
245 "-v",
246 };
247 optind = ARGV_START_INDEX;
248 RunCmds(tool, argc, const_cast<char**>(argv));
249 }
250
251 /**
252 * @tc.name: HiSysEventToolUnitTest008
253 * @tc.desc: Test subscribe sysevents in debug mode
254 * @tc.type: FUNC
255 * @tc.require: issueI66JWR
256 */
257 HWTEST_F(HiSysEventToolUnitTest, HiSysEventToolUnitTest008, testing::ext::TestSize.Level3)
258 {
259 auto tool = std::make_shared<HiSysEventTool>(false);
260 constexpr int argc = 3;
261 const char* argv[] = {
262 "hisysevent",
263 "-r",
264 "-d",
265 };
266 optind = ARGV_START_INDEX;
267 RunCmds(tool, argc, const_cast<char**>(argv));
268 }
269
270 /**
271 * @tc.name: HiSysEventToolUnitTest009
272 * @tc.desc: Test query hisysevents by event type
273 * @tc.type: FUNC
274 * @tc.require: issueI66JWR
275 */
276 HWTEST_F(HiSysEventToolUnitTest, HiSysEventToolUnitTest009, testing::ext::TestSize.Level3)
277 {
278 auto tool = std::make_shared<HiSysEventTool>(false);
279 constexpr int argc = 6;
280 const char* argv[] = {
281 "hisysevent",
282 "-l",
283 "-m",
284 "1",
285 "-g",
286 "SECURITY",
287 };
288 optind = ARGV_START_INDEX;
289 RunCmds(tool, argc, const_cast<char**>(argv));
290 }
291
292 /**
293 * @tc.name: HiSysEventToolUnitTest010
294 * @tc.desc: Test query hisysevents by default timestamp
295 * @tc.type: FUNC
296 * @tc.require: issueI66JWR
297 */
298 HWTEST_F(HiSysEventToolUnitTest, HiSysEventToolUnitTest010, testing::ext::TestSize.Level3)
299 {
300 auto tool = std::make_shared<HiSysEventTool>(false);
301 constexpr int argc = 9;
302 const char* argv[] = {
303 "hisysevent",
304 "-l",
305 "-m",
306 "1",
307 "-s",
308 "-1",
309 "-e",
310 "-1",
311 "-o",
312 };
313 optind = ARGV_START_INDEX;
314 RunCmds(tool, argc, const_cast<char**>(argv));
315 }
316
317 /**
318 * @tc.name: HiSysEventToolUnitTest011
319 * @tc.desc: Test query hisysevents by accurate timestamp
320 * @tc.type: FUNC
321 * @tc.require: issueI66JWR
322 */
323 HWTEST_F(HiSysEventToolUnitTest, HiSysEventToolUnitTest011, testing::ext::TestSize.Level3)
324 {
325 auto tool = std::make_shared<HiSysEventTool>(false);
326 constexpr int argc = 9;
327 auto endTimeStamp = GetMilliseconds();
328 int64_t offset = 1000;
329 auto beginTimeStamp = endTimeStamp - offset;
330 const char* argv[] = {
331 "hisysevent",
332 "-l",
333 "-m",
334 "1000",
335 "-s",
336 std::to_string(beginTimeStamp).c_str(),
337 "-e",
338 std::to_string(endTimeStamp).c_str(),
339 "-o",
340 };
341 optind = ARGV_START_INDEX;
342 RunCmds(tool, argc, const_cast<char**>(argv));
343 }
344
345 /**
346 * @tc.name: HiSysEventToolUnitTest012
347 * @tc.desc: Test query hisysevents by domain and event name
348 * @tc.type: FUNC
349 * @tc.require: issueI66JWR
350 */
351 HWTEST_F(HiSysEventToolUnitTest, HiSysEventToolUnitTest012, testing::ext::TestSize.Level3)
352 {
353 auto tool = std::make_shared<HiSysEventTool>(false);
354 constexpr int argc = 9;
355 const char* argv[] = {
356 "hisysevent",
357 "-l",
358 "-m",
359 "2000",
360 "-o",
361 "USERIAM_PIN",
362 "-n",
363 "USERIAM_TEMPLATE_CHANGE",
364 "-v",
365 };
366 optind = ARGV_START_INDEX;
367 RunCmds(tool, argc, const_cast<char**>(argv));
368 }
369
370 /**
371 * @tc.name: HiSysEventToolUnitTest013
372 * @tc.desc: Test APIs of class HiSysEventJsonDecorator
373 * @tc.type: FUNC
374 * @tc.require: issueI66JWR
375 */
376 HWTEST_F(HiSysEventToolUnitTest, HiSysEventToolUnitTest013, testing::ext::TestSize.Level3)
377 {
378 HiSysEventJsonDecorator decorator;
379 constexpr char origin0[] = "";
380 HiSysEventRecord record0(origin0);
381 auto ret = decorator.DecorateEventJsonStr(record0);
382 ASSERT_TRUE(ret.empty());
383 constexpr char origin1[] = "{\"domain_\":\"UNKNOWN_DOMAIN\"}";
384 HiSysEventRecord record1(origin1);
385 ret = decorator.DecorateEventJsonStr(record1);
386 ASSERT_EQ(ret, std::string(origin1));
387 constexpr char origin2[] = "{\"domain_\":\"USERIAM_PIN\",\"name_\":\"UNKNOWN_EVENTNAME\",\"type_\":3}";
388 HiSysEventRecord record2(origin2);
389 ret = decorator.DecorateEventJsonStr(record2);
390 ASSERT_EQ(ret, std::string(origin2));
391 }
392
393 /**
394 * @tc.name: HiSysEventToolUnitTest014
395 * @tc.desc: Test query hisysevents by valid formatted timestamp
396 * @tc.type: FUNC
397 * @tc.require: issueI68VXJ
398 */
399 HWTEST_F(HiSysEventToolUnitTest, HiSysEventToolUnitTest014, testing::ext::TestSize.Level3)
400 {
401 auto tool = std::make_shared<HiSysEventTool>(false);
402 constexpr int argc = 6;
403 const char* argv[] = {
404 "hisysevent",
405 "-l",
406 "-S",
407 "2023-01-05 10:28:33",
408 "-E",
409 "2023-01-05 10:29:33",
410 };
411 optind = ARGV_START_INDEX;
412 RunCmds(tool, argc, const_cast<char**>(argv));
413 }
414
415 /**
416 * @tc.name: HiSysEventToolUnitTest015
417 * @tc.desc: Test query hisysevents by invalid formatted timestamp
418 * @tc.type: FUNC
419 * @tc.require: issueI68VXJ
420 */
421 HWTEST_F(HiSysEventToolUnitTest, HiSysEventToolUnitTest015, testing::ext::TestSize.Level3)
422 {
423 auto tool = std::make_shared<HiSysEventTool>(false);
424 constexpr int argc = 6;
425 const char* argv[] = {
426 "hisysevent",
427 "-l",
428 "-S",
429 "2023-00-00 10:70:33",
430 "-E",
431 "2023-00-00 10:70:70",
432 };
433 optind = ARGV_START_INDEX;
434 RunCmds(tool, argc, const_cast<char**>(argv));
435 }
436 } // HiviewDFX
437 } // OHOS