1 /*
2  * Copyright (c) 2023-2024 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_wrote_result_check.h"
17 
18 #include <chrono>
19 #include <functional>
20 #include <iosfwd>
21 #include <limits>
22 #include <string>
23 #include <thread>
24 #include <unistd.h>
25 #include <vector>
26 
27 #include "gtest/gtest-message.h"
28 #include "gtest/gtest-test-part.h"
29 #include "gtest/hwext/gtest-ext.h"
30 #include "gtest/hwext/gtest-tag.h"
31 #include "hilog/log.h"
32 
33 #include "def.h"
34 #include "hisysevent.h"
35 #include "hisysevent_base_manager.h"
36 #include "hisysevent_manager.h"
37 #include "hisysevent_record.h"
38 #include "hisysevent_query_callback.h"
39 #include "hisysevent_listener.h"
40 #ifdef HIVIEWDFX_HITRACE_ENABLED_FOR_TEST
41 #include "hitrace/trace.h"
42 #endif
43 #include "ret_code.h"
44 #include "rule_type.h"
45 
46 #undef LOG_DOMAIN
47 #define LOG_DOMAIN 0xD002D08
48 
49 #undef LOG_TAG
50 #define LOG_TAG "HISYSEVENTTEST_WRITE_RESULT_CHECK_TEST"
51 
52 using namespace testing::ext;
53 using namespace OHOS::HiviewDFX;
54 
55 namespace {
56 constexpr char DOMAIN[] = "HIVIEWDFX";
57 constexpr char EVENT_NAME[] = "RECOVER";
58 constexpr char PARAM_KEY[] = "TEST_KEY";
59 constexpr int ARRAY_TOTAL_CNT = 3;
60 constexpr int FIRST_ITEM_INDEX = 0;
61 constexpr int SECOND_ITEM_INDEX = 1;
62 constexpr int THIRD_ITEM_INDEX = 2;
63 constexpr int USLEEP_SHORT_DURATION = 1000000;
64 constexpr int USLEEP_LONG_DURATION = 5000000;
65 
66 class Watcher : public HiSysEventListener {
67 public:
Watcher(std::function<bool (std::shared_ptr<HiSysEventRecord>)> assertFunc)68     explicit Watcher(std::function<bool(std::shared_ptr<HiSysEventRecord>)> assertFunc)
69     {
70         assertFunc_ = assertFunc;
71     }
72 
~Watcher()73     virtual ~Watcher() {}
74 
OnEvent(std::shared_ptr<HiSysEventRecord> sysEvent)75     void OnEvent(std::shared_ptr<HiSysEventRecord> sysEvent) final
76     {
77         if (sysEvent == nullptr || assertFunc_ == nullptr) {
78             return;
79         }
80         ASSERT_TRUE(assertFunc_(sysEvent));
81     }
82 
OnServiceDied()83     void OnServiceDied() final
84     {
85         HILOG_DEBUG(LOG_CORE, "OnServiceDied");
86     }
87 
88 private:
89     std::function<bool(std::shared_ptr<HiSysEventRecord>)> assertFunc_;
90 };
91 
92 template<typename T>
WriteAndWatchEvent(std::shared_ptr<Watcher> watcher,T & val)93 void WriteAndWatchEvent(std::shared_ptr<Watcher> watcher, T& val)
94 {
95     OHOS::HiviewDFX::ListenerRule listenerRule(DOMAIN, EVENT_NAME, "",
96         OHOS::HiviewDFX::RuleType::WHOLE_WORD);
97     std::vector<OHOS::HiviewDFX::ListenerRule> sysRules;
98     sysRules.emplace_back(listenerRule);
99     auto ret = OHOS::HiviewDFX::HiSysEventManager::AddListener(watcher, sysRules);
100     ASSERT_EQ(ret, SUCCESS);
101     ret = HiSysEventWrite(DOMAIN, EVENT_NAME, HiSysEvent::EventType::BEHAVIOR, PARAM_KEY,
102         val);
103     ASSERT_EQ(ret, SUCCESS);
104     usleep(USLEEP_LONG_DURATION);
105     ret = OHOS::HiviewDFX::HiSysEventManager::RemoveListener(watcher);
106     ASSERT_EQ(ret, SUCCESS);
107 }
108 
IsContains(const std::string & total,const std::string & part)109 bool IsContains(const std::string& total, const std::string& part)
110 {
111     if (total.empty() || part.empty()) {
112         return false;
113     }
114     return total.find(part) != std::string::npos;
115 }
116 }
117 
SetUpTestCase(void)118 void HiSysEventWroteResultCheckTest::SetUpTestCase(void)
119 {
120 }
121 
TearDownTestCase(void)122 void HiSysEventWroteResultCheckTest::TearDownTestCase(void)
123 {
124 }
125 
SetUp(void)126 void HiSysEventWroteResultCheckTest::SetUp(void)
127 {
128 }
129 
TearDown(void)130 void HiSysEventWroteResultCheckTest::TearDown(void)
131 {
132 }
133 
134 /**
135  * @tc.name: HiSysEventWroteResultCheckTest001
136  * @tc.desc: Write sysevent with bool parameter
137  * @tc.type: FUNC
138  * @tc.require: issueI76V6J
139  */
140 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest001, TestSize.Level1)
141 {
142     usleep(USLEEP_SHORT_DURATION);
143     bool val = true;
__anon1cb05ef20202(std::shared_ptr<HiSysEventRecord> sysEvent) 144     auto watcher = std::make_shared<Watcher>([val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
145         if (sysEvent == nullptr) {
146             return false;
147         }
148         int64_t ret;
149         sysEvent->GetParamValue(PARAM_KEY, ret);
150         return ret == static_cast<int>(val);
151     });
152     WriteAndWatchEvent(watcher, val);
153 }
154 
155 /**
156  * @tc.name: HiSysEventWroteResultCheckTest002
157  * @tc.desc: Write sysevent with int64_t parameter
158  * @tc.type: FUNC
159  * @tc.require: issueI76V6J
160  */
161 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest002, TestSize.Level1)
162 {
163     usleep(USLEEP_SHORT_DURATION);
164     int64_t val = -18888888882321;
__anon1cb05ef20302(std::shared_ptr<HiSysEventRecord> sysEvent) 165     auto watcher = std::make_shared<Watcher>([val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
166         if (sysEvent == nullptr) {
167             return false;
168         }
169         int64_t ret;
170         sysEvent->GetParamValue(PARAM_KEY, ret);
171         return ret == val;
172     });
173     WriteAndWatchEvent(watcher, val);
174 }
175 
176 /**
177  * @tc.name: HiSysEventWroteResultCheckTest003
178  * @tc.desc: Write sysevent with uint64_t parameter
179  * @tc.type: FUNC
180  * @tc.require: issueI76V6J
181  */
182 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest003, TestSize.Level1)
183 {
184     usleep(USLEEP_SHORT_DURATION);
185     uint64_t val = 18888888882326141;
__anon1cb05ef20402(std::shared_ptr<HiSysEventRecord> sysEvent) 186     auto watcher = std::make_shared<Watcher>([val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
187         if (sysEvent == nullptr) {
188             return false;
189         }
190         uint64_t ret;
191         sysEvent->GetParamValue(PARAM_KEY, ret);
192         return ret == val;
193     });
194     WriteAndWatchEvent(watcher, val);
195 }
196 
197 /**
198  * @tc.name: HiSysEventWroteResultCheckTest004
199  * @tc.desc: Write sysevent with double parameter
200  * @tc.type: FUNC
201  * @tc.require: issueI76V6J
202  */
203 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest004, TestSize.Level1)
204 {
205     usleep(USLEEP_SHORT_DURATION);
206     double val = 30949.374;
__anon1cb05ef20502(std::shared_ptr<HiSysEventRecord> sysEvent) 207     auto watcher = std::make_shared<Watcher>([val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
208         if (sysEvent == nullptr) {
209             return false;
210         }
211         std::string eventJsonStr = sysEvent->AsJson();
212         return IsContains(eventJsonStr, "\"" + std::string(PARAM_KEY) + "\":30949.4,");
213     });
214     WriteAndWatchEvent(watcher, val);
215 }
216 
217 /**
218  * @tc.name: HiSysEventWroteResultCheckTest005
219  * @tc.desc: Write sysevent with string parameter
220  * @tc.type: FUNC
221  * @tc.require: issueI76V6J
222  */
223 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest005, TestSize.Level1)
224 {
225     usleep(USLEEP_SHORT_DURATION);
226     std::string val = "value";
__anon1cb05ef20602(std::shared_ptr<HiSysEventRecord> sysEvent) 227     auto watcher = std::make_shared<Watcher>([val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
228         if (sysEvent == nullptr) {
229             return false;
230         }
231         std::string ret;
232         sysEvent->GetParamValue(PARAM_KEY, ret);
233         return ret == val;
234     });
235     WriteAndWatchEvent(watcher, val);
236 }
237 
238 /**
239  * @tc.name: HiSysEventWroteResultCheckTest006
240  * @tc.desc: Write sysevent with bool array parameter
241  * @tc.type: FUNC
242  * @tc.require: issueI76V6J
243  */
244 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest006, TestSize.Level1)
245 {
246     usleep(USLEEP_SHORT_DURATION);
247     std::vector<bool> val = {
248         true,
249         false,
250         true
251     };
__anon1cb05ef20702(std::shared_ptr<HiSysEventRecord> sysEvent) 252     auto watcher = std::make_shared<Watcher>([&val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
253         if (sysEvent == nullptr) {
254             return false;
255         }
256         std::vector<int64_t> ret;
257         sysEvent->GetParamValue(PARAM_KEY, ret);
258         return (ret.size() == ARRAY_TOTAL_CNT) && (val[FIRST_ITEM_INDEX] == ret[FIRST_ITEM_INDEX]) &&
259             (val[SECOND_ITEM_INDEX] == ret[SECOND_ITEM_INDEX]) && (val[THIRD_ITEM_INDEX] == ret[THIRD_ITEM_INDEX]);
260     });
261     WriteAndWatchEvent(watcher, val);
262 }
263 
264 /**
265  * @tc.name: HiSysEventWroteResultCheckTest007
266  * @tc.desc: Write sysevent with int64_t array parameter
267  * @tc.type: FUNC
268  * @tc.require: issueI76V6J
269  */
270 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest007, TestSize.Level1)
271 {
272     usleep(USLEEP_SHORT_DURATION);
273     std::vector<int64_t> val = {
274         std::numeric_limits<int64_t>::min(),
275         std::numeric_limits<int64_t>::max(),
276         -3333333333333333333,
277     };
__anon1cb05ef20802(std::shared_ptr<HiSysEventRecord> sysEvent) 278     auto watcher = std::make_shared<Watcher>([&val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
279         if (sysEvent == nullptr) {
280             return false;
281         }
282         std::vector<int64_t> ret;
283         sysEvent->GetParamValue(PARAM_KEY, ret);
284         return (ret.size() == ARRAY_TOTAL_CNT) && (val[FIRST_ITEM_INDEX] == ret[FIRST_ITEM_INDEX]) &&
285             (val[SECOND_ITEM_INDEX] == ret[SECOND_ITEM_INDEX]) && (val[THIRD_ITEM_INDEX] == ret[THIRD_ITEM_INDEX]);
286     });
287     WriteAndWatchEvent(watcher, val);
288 }
289 
290 /**
291  * @tc.name: HiSysEventWroteResultCheckTest008
292  * @tc.desc: Write sysevent with uint64_t array parameter
293  * @tc.type: FUNC
294  * @tc.require: issueI76V6J
295  */
296 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest008, TestSize.Level1)
297 {
298     usleep(USLEEP_SHORT_DURATION);
299     std::vector<uint64_t> val = {
300         std::numeric_limits<uint64_t>::min(),
301         std::numeric_limits<uint64_t>::max(),
302         3333333333333333333,
303     };
__anon1cb05ef20902(std::shared_ptr<HiSysEventRecord> sysEvent) 304     auto watcher = std::make_shared<Watcher>([&val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
305         if (sysEvent == nullptr) {
306             return false;
307         }
308         std::vector<uint64_t> ret;
309         sysEvent->GetParamValue(PARAM_KEY, ret);
310         return (ret.size() == ARRAY_TOTAL_CNT) && (val[FIRST_ITEM_INDEX] == ret[FIRST_ITEM_INDEX]) &&
311             (val[SECOND_ITEM_INDEX] == ret[SECOND_ITEM_INDEX]) && (val[THIRD_ITEM_INDEX] == ret[THIRD_ITEM_INDEX]);
312     });
313     WriteAndWatchEvent(watcher, val);
314 }
315 
316 /**
317  * @tc.name: HiSysEventWroteResultCheckTest009
318  * @tc.desc: Write sysevent with double array parameter
319  * @tc.type: FUNC
320  * @tc.require: issueI76V6J
321  */
322 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest009, TestSize.Level1)
323 {
324     usleep(USLEEP_SHORT_DURATION);
325     std::vector<double> val = {
326         1.5,
327         2.5,
328         100.374,
329     };
__anon1cb05ef20a02(std::shared_ptr<HiSysEventRecord> sysEvent) 330     auto watcher = std::make_shared<Watcher>([&val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
331         if (sysEvent == nullptr) {
332             return false;
333         }
334         std::string eventJsonStr = sysEvent->AsJson();
335         return IsContains(eventJsonStr, "\"" + std::string(PARAM_KEY) + "\":[1.5,2.5,100.374],");
336     });
337     WriteAndWatchEvent(watcher, val);
338 }
339 
340 /**
341  * @tc.name: HiSysEventWroteResultCheckTest010
342  * @tc.desc: Write sysevent with string array parameter
343  * @tc.type: FUNC
344  * @tc.require: issueI76V6J
345  */
346 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest010, TestSize.Level1)
347 {
348     usleep(USLEEP_SHORT_DURATION);
349     std::vector<std::string> val = {
350         "value1\n\r",
351         "value2\n\r",
352         "value3\n\r",
353     };
__anon1cb05ef20b02(std::shared_ptr<HiSysEventRecord> sysEvent) 354     auto watcher = std::make_shared<Watcher>([&val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
355         if (sysEvent == nullptr) {
356             return false;
357         }
358         std::vector<std::string> ret;
359         sysEvent->GetParamValue(PARAM_KEY, ret);
360         return (ret.size() == ARRAY_TOTAL_CNT) && (ret[FIRST_ITEM_INDEX] == "value1\n\r") &&
361             (ret[SECOND_ITEM_INDEX] == "value2\n\r") && (ret[THIRD_ITEM_INDEX] == "value3\n\r");
362     });
363     WriteAndWatchEvent(watcher, val);
364 }
365 
366 /**
367  * @tc.name: HiSysEventWroteResultCheckTest011
368  * @tc.desc: Write sysevent with float parameter
369  * @tc.type: FUNC
370  * @tc.require: issueI76V6J
371  */
372 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest011, TestSize.Level1)
373 {
374     usleep(USLEEP_SHORT_DURATION);
375     float val = 230.47;
__anon1cb05ef20c02(std::shared_ptr<HiSysEventRecord> sysEvent) 376     auto watcher = std::make_shared<Watcher>([val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
377         if (sysEvent == nullptr) {
378             return false;
379         }
380         std::string eventJsonStr = sysEvent->AsJson();
381         return IsContains(eventJsonStr, "\"" + std::string(PARAM_KEY) + "\":230.47,");
382     });
383     WriteAndWatchEvent(watcher, val);
384 }
385 
386 /**
387  * @tc.name: HiSysEventWroteResultCheckTest012
388  * @tc.desc: Write sysevent with float array parameter
389  * @tc.type: FUNC
390  * @tc.require: issueI76V6J
391  */
392 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest012, TestSize.Level1)
393 {
394     usleep(USLEEP_SHORT_DURATION);
395     std::vector<float> val = {
396         1.1,
397         2.2,
398         3.5,
399         4,
400     };
__anon1cb05ef20d02(std::shared_ptr<HiSysEventRecord> sysEvent) 401     auto watcher = std::make_shared<Watcher>([&val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
402         if (sysEvent == nullptr) {
403             return false;
404         }
405         std::string eventJsonStr = sysEvent->AsJson();
406         return IsContains(eventJsonStr, "\"" + std::string(PARAM_KEY) + "\":[1.1,2.2,3.5,4],");
407     });
408     WriteAndWatchEvent(watcher, val);
409 }
410 
411 #ifdef HIVIEWDFX_HITRACE_ENABLED_FOR_TEST
412 /**
413  * @tc.name: HiSysEventWroteResultCheckTest013
414  * @tc.desc: Write sysevent after begin hitracechain
415  * @tc.type: FUNC
416  * @tc.require: issueI76V6J
417  */
418 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest013, TestSize.Level1)
419 {
420     usleep(USLEEP_SHORT_DURATION);
421     std::string val = "with valid hitracechain";
422     auto traceId = HiTraceChain::Begin("TestCase1", HITRACE_FLAG_INCLUDE_ASYNC | HITRACE_FLAG_DONOT_CREATE_SPAN);
__anon1cb05ef20e02(std::shared_ptr<HiSysEventRecord> sysEvent) 423     auto watcher = std::make_shared<Watcher>([&val, &traceId] (std::shared_ptr<HiSysEventRecord> sysEvent) {
424         if (sysEvent == nullptr) {
425             return false;
426         }
427         return (traceId.GetFlags() == sysEvent->GetTraceFlag()) && (traceId.GetChainId() == sysEvent->GetTraceId());
428     });
429     WriteAndWatchEvent(watcher, val);
430     HiTraceChain::End(traceId);
431 }
432 #endif
433 
434 /**
435  * @tc.name: HiSysEventWroteResultCheckTest014
436  * @tc.desc: Write sysevent with negative double parameter
437  * @tc.type: FUNC
438  * @tc.require: issueI76V6J
439  */
440 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest014, TestSize.Level1)
441 {
442     usleep(USLEEP_SHORT_DURATION);
443     double val = -3.5;
__anon1cb05ef20f02(std::shared_ptr<HiSysEventRecord> sysEvent) 444     auto watcher = std::make_shared<Watcher>([val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
445         if (sysEvent == nullptr) {
446             return false;
447         }
448         std::string eventJsonStr = sysEvent->AsJson();
449         return IsContains(eventJsonStr, "\"" + std::string(PARAM_KEY) + "\":-3.5,");
450     });
451     WriteAndWatchEvent(watcher, val);
452 }
453 
454 /**
455  * @tc.name: HiSysEventWroteResultCheckTest015
456  * @tc.desc: Write sysevent with empty array
457  * @tc.type: FUNC
458  * @tc.require: issueI76V6J
459  */
460 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest015, TestSize.Level1)
461 {
462     usleep(USLEEP_SHORT_DURATION);
463     std::vector<float> val;
__anon1cb05ef21002(std::shared_ptr<HiSysEventRecord> sysEvent) 464     auto watcher = std::make_shared<Watcher>([val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
465         if (sysEvent == nullptr) {
466             return false;
467         }
468         std::string eventJsonStr = sysEvent->AsJson();
469         return IsContains(eventJsonStr, "\"" + std::string(PARAM_KEY) + "\":[],");
470     });
471     WriteAndWatchEvent(watcher, val);
472 }
473 
474 /**
475  * @tc.name: HiSysEventWroteResultCheckTest016
476  * @tc.desc: Write sysevent with maximum int64_t value
477  * @tc.type: FUNC
478  * @tc.require: issueI76V6J
479  */
480 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest016, TestSize.Level1)
481 {
482     usleep(USLEEP_SHORT_DURATION);
483     int64_t val = std::numeric_limits<int64_t>::max();
__anon1cb05ef21102(std::shared_ptr<HiSysEventRecord> sysEvent) 484     auto watcher = std::make_shared<Watcher>([val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
485         if (sysEvent == nullptr) {
486             return false;
487         }
488         int64_t ret;
489         sysEvent->GetParamValue(PARAM_KEY, ret);
490         return ret == val;
491     });
492     WriteAndWatchEvent(watcher, val);
493 }
494 
495 /**
496  * @tc.name: HiSysEventWroteResultCheckTest017
497  * @tc.desc: Write sysevent with minimum int64_t value
498  * @tc.type: FUNC
499  * @tc.require: issueI76V6J
500  */
501 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest017, TestSize.Level1)
502 {
503     usleep(USLEEP_SHORT_DURATION);
504     int64_t val = std::numeric_limits<int64_t>::min();
__anon1cb05ef21202(std::shared_ptr<HiSysEventRecord> sysEvent) 505     auto watcher = std::make_shared<Watcher>([val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
506         if (sysEvent == nullptr) {
507             return false;
508         }
509         int64_t ret;
510         sysEvent->GetParamValue(PARAM_KEY, ret);
511         return ret == val;
512     });
513     WriteAndWatchEvent(watcher, val);
514 }
515 
516 /**
517  * @tc.name: HiSysEventWroteResultCheckTest018
518  * @tc.desc: Write sysevent with maximum uint64_t value
519  * @tc.type: FUNC
520  * @tc.require: issueI76V6J
521  */
522 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest018, TestSize.Level1)
523 {
524     usleep(USLEEP_SHORT_DURATION);
525     uint64_t val = std::numeric_limits<uint64_t>::max();
__anon1cb05ef21302(std::shared_ptr<HiSysEventRecord> sysEvent) 526     auto watcher = std::make_shared<Watcher>([val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
527         if (sysEvent == nullptr) {
528             return false;
529         }
530         uint64_t ret;
531         sysEvent->GetParamValue(PARAM_KEY, ret);
532         return ret == val;
533     });
534     WriteAndWatchEvent(watcher, val);
535 }
536 
537 /**
538  * @tc.name: HiSysEventWroteResultCheckTest019
539  * @tc.desc: Write sysevent with minimum uint64_t value
540  * @tc.type: FUNC
541  * @tc.require: issueI76V6J
542  */
543 HWTEST_F(HiSysEventWroteResultCheckTest, HiSysEventWroteResultCheckTest019, TestSize.Level1)
544 {
545     usleep(USLEEP_SHORT_DURATION);
546     uint64_t val = std::numeric_limits<uint64_t>::min();
__anon1cb05ef21402(std::shared_ptr<HiSysEventRecord> sysEvent) 547     auto watcher = std::make_shared<Watcher>([val] (std::shared_ptr<HiSysEventRecord> sysEvent) {
548         if (sysEvent == nullptr) {
549             return false;
550         }
551         uint64_t ret;
552         sysEvent->GetParamValue(PARAM_KEY, ret);
553         return ret == val;
554     });
555     WriteAndWatchEvent(watcher, val);
556 }