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 <cstdlib>
17 #include <ctime>
18 #include <gtest/gtest.h>
19
20 #include "caution.h"
21 #include "hichecker.h"
22
23 using namespace testing::ext;
24 using namespace OHOS::HiviewDFX;
25
26 namespace {
27 const int64_t SEC_TO_NS = 1000000000;
28 const int64_t MAX_CALL_DURATION_US = 1000; // 1ms
29 const int LOOP_COUNT = 1000;
30 const uint64_t RULE_ERROR0 = 0;
31 const uint64_t RULE_ERROR1 = -1;
32 const uint64_t RULE_ERROR2 = 999999999;
33 }
34
35 namespace OHOS {
36 namespace HiviewDFX {
37 class HiCheckerNativeTest : public testing::Test {
38 public:
SerUpTestCase()39 static void SerUpTestCase() {};
TearDownTestCase()40 static void TearDownTestCase() {};
41 void SetUp();
42 void TearDown();
43 };
44
SetUp(void)45 void HiCheckerNativeTest::SetUp(void)
46 {
47 HiChecker::RemoveRule(Rule::ALL_RULES);
48 }
49
TearDown(void)50 void HiCheckerNativeTest::TearDown(void)
51 {
52 HiChecker::RemoveRule(Rule::ALL_RULES);
53 }
54
GetTimeNs()55 static int64_t GetTimeNs()
56 {
57 struct timespec ts;
58 clock_gettime(CLOCK_REALTIME, &ts);
59 return ts.tv_sec * SEC_TO_NS + ts.tv_nsec;
60 }
61
62 /**
63 * @tc.name: AddRule001
64 * @tc.desc: add only one rule
65 * @tc.type: FUNC
66 */
67 HWTEST_F(HiCheckerNativeTest, AddRuleTest001, TestSize.Level1)
68 {
69 uint64_t rule = Rule::RULE_THREAD_CHECK_SLOW_PROCESS;
70 HiChecker::AddRule(Rule::RULE_THREAD_CHECK_SLOW_PROCESS);
71 ASSERT_EQ(HiChecker::GetRule(), rule);
72 rule |= Rule::RULE_CAUTION_PRINT_LOG;
73 HiChecker::AddRule(Rule::RULE_CAUTION_PRINT_LOG);
74 ASSERT_EQ(HiChecker::GetRule(), rule);
75 }
76
77 /**
78 * @tc.name: AddRule002
79 * @tc.desc: add two or more rules
80 * @tc.type: FUNC
81 */
82 HWTEST_F(HiCheckerNativeTest, AddRuleTest002, TestSize.Level1)
83 {
84 uint64_t rule = Rule::RULE_THREAD_CHECK_SLOW_PROCESS |
85 Rule::RULE_CHECK_SLOW_EVENT | Rule::RULE_CHECK_ABILITY_CONNECTION_LEAK;
86 HiChecker::AddRule(Rule::RULE_THREAD_CHECK_SLOW_PROCESS |
87 Rule::RULE_CHECK_SLOW_EVENT | Rule::RULE_CHECK_ABILITY_CONNECTION_LEAK);
88 ASSERT_EQ(HiChecker::GetRule(), rule);
89 rule |= (Rule::RULE_CAUTION_PRINT_LOG | Rule::RULE_CAUTION_TRIGGER_CRASH);
90 HiChecker::AddRule(Rule::RULE_CAUTION_PRINT_LOG | Rule::RULE_CAUTION_TRIGGER_CRASH);
91 ASSERT_EQ(HiChecker::GetRule(), rule);
92 }
93
94 /**
95 * @tc.name: AddRule003
96 * @tc.desc: add invaild rule
97 * @tc.type: FUNC
98 */
99 HWTEST_F(HiCheckerNativeTest, AddRuleTest003, TestSize.Level1)
100 {
101 HiChecker::AddRule(RULE_ERROR0);
102 ASSERT_EQ(HiChecker::GetRule(), 0);
103 HiChecker::AddRule(RULE_ERROR1);
104 ASSERT_EQ(HiChecker::GetRule(), 0);
105 HiChecker::AddRule(RULE_ERROR2);
106 ASSERT_EQ(HiChecker::GetRule(), 0);
107 }
108
109 /**
110 * @tc.name: AddRulePerf
111 * @tc.desc: test performance for AddRule
112 * @tc.type: PERF
113 */
114 HWTEST_F(HiCheckerNativeTest, AddRulePerfTest001, TestSize.Level2)
115 {
116 int64_t total = 0;
117 for (int i = 0; i < LOOP_COUNT; i++) {
118 int64_t start = GetTimeNs();
119 HiChecker::AddRule(Rule::RULE_CHECK_SLOW_EVENT);
120 int64_t duration = GetTimeNs() - start;
121 total += duration;
122 }
123 int64_t duration = (total / LOOP_COUNT);
124 duration = duration / 1000;
125 ASSERT_TRUE(duration < MAX_CALL_DURATION_US);
126 }
127
128 /**
129 * @tc.name: RemoveRule001
130 * @tc.desc: remove only one rule
131 * @tc.type: FUNC
132 */
133 HWTEST_F(HiCheckerNativeTest, RemoveRuleTest001, TestSize.Level1)
134 {
135 HiChecker::AddRule(Rule::ALL_RULES);
136 HiChecker::RemoveRule(Rule::RULE_CAUTION_TRIGGER_CRASH);
137 ASSERT_FALSE(HiChecker::Contains(Rule::RULE_CAUTION_TRIGGER_CRASH));
138 HiChecker::RemoveRule(Rule::RULE_CAUTION_PRINT_LOG);
139 ASSERT_FALSE(HiChecker::Contains(Rule::RULE_CAUTION_PRINT_LOG));
140 uint64_t rule = Rule::ALL_RULES ^ (Rule::RULE_CAUTION_PRINT_LOG | Rule::RULE_CAUTION_TRIGGER_CRASH);
141 ASSERT_EQ(HiChecker::GetRule(), rule);
142 }
143
144 /**
145 * @tc.name: RemoveRule002
146 * @tc.desc: remove two or more rules
147 * @tc.type: FUNC
148 */
149 HWTEST_F(HiCheckerNativeTest, RemoveRuleTest002, TestSize.Level1)
150 {
151 HiChecker::AddRule(Rule::ALL_RULES);
152 HiChecker::RemoveRule(Rule::RULE_CAUTION_TRIGGER_CRASH | Rule::RULE_CAUTION_PRINT_LOG);
153 ASSERT_FALSE(HiChecker::Contains(Rule::RULE_CAUTION_TRIGGER_CRASH));
154 ASSERT_FALSE(HiChecker::Contains(Rule::RULE_CAUTION_PRINT_LOG));
155 uint64_t rule = Rule::ALL_RULES ^ (Rule::RULE_CAUTION_PRINT_LOG | Rule::RULE_CAUTION_TRIGGER_CRASH);
156 ASSERT_EQ(HiChecker::GetRule(), rule);
157 }
158
159 /**
160 * @tc.name: RemoveRule003
161 * @tc.desc: remove invaild rule
162 * @tc.type: FUNC
163 */
164 HWTEST_F(HiCheckerNativeTest, RemoveRuleTest003, TestSize.Level1)
165 {
166 HiChecker::AddRule(Rule::ALL_RULES);
167 HiChecker::RemoveRule(RULE_ERROR0);
168 ASSERT_EQ(HiChecker::GetRule(), Rule::ALL_RULES);
169 HiChecker::RemoveRule(RULE_ERROR1);
170 ASSERT_EQ(HiChecker::GetRule(), Rule::ALL_RULES);
171 HiChecker::RemoveRule(RULE_ERROR2);
172 ASSERT_EQ(HiChecker::GetRule(), Rule::ALL_RULES);
173 }
174
175 /**
176 * @tc.name: RemoveRulePerf
177 * @tc.desc: test performance for RemoveRule
178 * @tc.type: PERF
179 */
180 HWTEST_F(HiCheckerNativeTest, RemoveRulePerfTest001, TestSize.Level2)
181 {
182 int64_t total = 0;
183 for (int i = 0; i < LOOP_COUNT; i++) {
184 int64_t start = GetTimeNs();
185 HiChecker::RemoveRule(Rule::RULE_CHECK_SLOW_EVENT);
186 int64_t duration = GetTimeNs() - start;
187 total += duration;
188 }
189 int64_t duration = (total / LOOP_COUNT);
190 duration = duration / 1000;
191 ASSERT_TRUE(duration < MAX_CALL_DURATION_US);
192 }
193
194 /**
195 * @tc.name: Contains001
196 * @tc.desc: test Contains
197 * @tc.type: FUNC
198 */
199 HWTEST_F(HiCheckerNativeTest, ContainsTest001, TestSize.Level1)
200 {
201 HiChecker::AddRule(Rule::RULE_CAUTION_PRINT_LOG);
202 ASSERT_TRUE(HiChecker::Contains(Rule::RULE_CAUTION_PRINT_LOG));
203 ASSERT_FALSE(HiChecker::Contains(Rule::RULE_CAUTION_TRIGGER_CRASH));
204 ASSERT_FALSE(HiChecker::Contains(Rule::RULE_CAUTION_PRINT_LOG | Rule::RULE_CAUTION_TRIGGER_CRASH));
205 }
206
207 /**
208 * @tc.name: Contains002
209 * @tc.desc: test Contains with invaild rule
210 * @tc.type: FUNC
211 */
212 HWTEST_F(HiCheckerNativeTest, ContainsTest002, TestSize.Level1)
213 {
214 HiChecker::AddRule(Rule::ALL_RULES);
215 ASSERT_FALSE(HiChecker::Contains(RULE_ERROR0));
216 ASSERT_FALSE(HiChecker::Contains(RULE_ERROR1));
217 ASSERT_FALSE(HiChecker::Contains(RULE_ERROR2));
218 }
219
220 /**
221 * @tc.name: CautionTest001
222 * @tc.desc: test Caution
223 * @tc.type: FUNC
224 */
225 HWTEST_F(HiCheckerNativeTest, CautionTest001, TestSize.Level1)
226 {
227 Caution caution;
228 caution.SetTriggerRule(Rule::RULE_CAUTION_PRINT_LOG);
229 EXPECT_EQ(caution.GetTriggerRule(), Rule::RULE_CAUTION_PRINT_LOG);
230
231 caution.SetStackTrace("stack_trace");
232 EXPECT_EQ(caution.GetStackTrace(), "stack_trace");
233
234 caution.SetCautionMsg("caution_msg");
235 EXPECT_EQ(caution.GetCautionMsg(), "caution_msg");
236 }
237
238 /**
239 * @tc.name: NotifySlowProcessTest001
240 * @tc.desc: test NotifySlowProcess
241 * @tc.type: FUNC
242 */
243 HWTEST_F(HiCheckerNativeTest, NotifySlowProcessTest001, TestSize.Level1)
244 {
245 HiChecker::AddRule(RULE_ERROR0);
246 std::string eventTag = "NotifySlowProcessTest001";
247 HiChecker::NotifySlowProcess(eventTag);
248 HiChecker::AddRule(Rule::RULE_THREAD_CHECK_SLOW_PROCESS);
249 ASSERT_EQ(HiChecker::GetRule(), Rule::RULE_THREAD_CHECK_SLOW_PROCESS);
250 HiChecker::NotifySlowProcess(eventTag);
251 HiChecker::RemoveRule(Rule::RULE_CHECK_SLOW_EVENT);
252 }
253
254 /**
255 * @tc.name: NotifyAbilityConnectionLeakTest001
256 * @tc.desc: test NotifyAbilityConnectionLeak
257 * @tc.type: FUNC
258 */
259 HWTEST_F(HiCheckerNativeTest, NotifyAbilityConnectionLeakTest001, TestSize.Level1)
260 {
261 std::string cautionMsg = "NotifyAbilityConnectionLeakTest001";
262 std::string stackTrace = "stackTrace";
263 Caution cautionError(RULE_ERROR0, cautionMsg, "stackTrace");
264 HiChecker::NotifyAbilityConnectionLeak(cautionError);
265 Caution caution(Rule::RULE_CHECK_ABILITY_CONNECTION_LEAK, cautionMsg, stackTrace);
266 HiChecker::NotifyAbilityConnectionLeak(caution);
267 EXPECT_EQ(caution.GetStackTrace(), stackTrace);
268 EXPECT_EQ(caution.GetCautionMsg(), cautionMsg);
269 }
270
271 /**
272 * @tc.name: NotifySlowEventTest001
273 * @tc.desc: test PrintLog
274 * @tc.type: FUNC
275 */
276 HWTEST_F(HiCheckerNativeTest, NotifySlowEventTest001, TestSize.Level1)
277 {
278 HiChecker::AddRule(RULE_ERROR0);
279 std::string eventTag = "NotifySlowEventTest001 time out";
280 HiChecker::NotifySlowEvent(eventTag);
281 HiChecker::AddRule(Rule::RULE_CHECK_SLOW_EVENT);
282 ASSERT_TRUE(HiChecker::NeedCheckSlowEvent());
283 HiChecker::NotifySlowEvent(eventTag);
284 HiChecker::RemoveRule(Rule::RULE_CHECK_SLOW_EVENT);
285 }
286
287 /**
288 * @tc.name: NotifyCautionTest001
289 * @tc.desc: test NotifyCaution
290 * @tc.type: FUNC
291 */
292 HWTEST_F(HiCheckerNativeTest, NotifyCautionTest001, TestSize.Level1)
293 {
294 HiChecker::AddRule(RULE_ERROR0);
295 Caution caution;
296 std::string tag = "error_tag";
297 HiChecker::NotifyCaution(RULE_ERROR0, tag, caution);
298 ASSERT_EQ(HiChecker::GetRule(), 0);
299 }
300
301 /**
302 * @tc.name: NotifyCautionTest002
303 * @tc.desc: test NotifyCaution
304 * @tc.type: FUNC
305 */
306 HWTEST_F(HiCheckerNativeTest, NotifyCautionTest002, TestSize.Level1)
307 {
308 HiChecker::AddRule(Rule::RULE_CHECK_ARKUI_PERFORMANCE);
309 std::string tag = "arkui_tag";
310 Caution caution;
311 caution.SetTriggerRule(Rule::RULE_CHECK_ARKUI_PERFORMANCE);
312 HiChecker::NotifyCaution(Rule::RULE_CHECK_ARKUI_PERFORMANCE, tag, caution);
313 HiChecker::RemoveRule(Rule::RULE_CHECK_ARKUI_PERFORMANCE);
314 EXPECT_EQ(caution.GetCautionMsg(), "trigger:RULE_CHECK_ARKUI_PERFORMANCE,arkui_tag");
315 }
316
317 /**
318 * @tc.name: NotifyCautionTest003
319 * @tc.desc: test NotifyCaution
320 * @tc.type: FUNC
321 */
322 HWTEST_F(HiCheckerNativeTest, NotifyCautionTest003, TestSize.Level1)
323 {
324 HiChecker::AddRule(Rule::RULE_THREAD_CHECK_SLOW_PROCESS);
325 std::string tag = "slow_process_tag";
326 Caution caution;
327 caution.SetTriggerRule(Rule::RULE_THREAD_CHECK_SLOW_PROCESS);
328 HiChecker::NotifyCaution(Rule::RULE_THREAD_CHECK_SLOW_PROCESS, tag, caution);
329 HiChecker::RemoveRule(Rule::RULE_THREAD_CHECK_SLOW_PROCESS);
330 EXPECT_EQ(caution.GetCautionMsg(), "trigger:RULE_THREAD_CHECK_SLOW_PROCESS,slow_process_tag");
331 }
332
333 /**
334 * @tc.name: NotifyCautionTest004
335 * @tc.desc: test NotifyCaution
336 * @tc.type: FUNC
337 */
338 HWTEST_F(HiCheckerNativeTest, NotifyCautionTest004, TestSize.Level1)
339 {
340 HiChecker::AddRule(Rule::RULE_CHECK_SLOW_EVENT);
341 std::string tag = "slow_event_tag";
342 Caution caution;
343 caution.SetTriggerRule(Rule::RULE_CHECK_SLOW_EVENT);
344 HiChecker::NotifyCaution(Rule::RULE_CHECK_SLOW_EVENT, tag, caution);
345 HiChecker::RemoveRule(Rule::RULE_CHECK_SLOW_EVENT);
346 EXPECT_EQ(caution.GetCautionMsg(), "trigger:RULE_CHECK_SLOW_EVENT,slow_event_tag");
347 }
348
349 /**
350 * @tc.name: InitHicheckerParamTest001
351 * @tc.desc: test InitHicheckerParam
352 * @tc.type: FUNC
353 */
354 HWTEST_F(HiCheckerNativeTest, InitHicheckerParamTest001, TestSize.Level1)
355 {
356 system("param set hiviewdfx.hichecker.checker_test 17179869184");
357 const char *processName = "checker_test111";
358 HiChecker::InitHicheckerParam(processName);
359 ASSERT_FALSE(HiChecker::Contains(Rule::RULE_CHECK_ARKUI_PERFORMANCE));
360 }
361
362 /**
363 * @tc.name: InitHicheckerParamTest002
364 * @tc.desc: test InitHicheckerParam
365 * @tc.type: FUNC
366 */
367 HWTEST_F(HiCheckerNativeTest, InitHicheckerParamTest002, TestSize.Level1)
368 {
369 system("param set hiviewdfx.hichecker.checker_test 17179869184");
370 const char *processName = "checker_test";
371 HiChecker::InitHicheckerParam(processName);
372 ASSERT_TRUE(HiChecker::Contains(Rule::RULE_CHECK_ARKUI_PERFORMANCE));
373 }
374
375 /**
376 * @tc.name: InitHicheckerParamTest003
377 * @tc.desc: test InitHicheckerParam
378 * @tc.type: FUNC
379 */
380 HWTEST_F(HiCheckerNativeTest, InitHicheckerParamTest003, TestSize.Level1)
381 {
382 const char *processName = "test.process.name.maxlength.greatthan.eighteen.aaaaaaaaaaaaaaaaaaaaaaaaaaa";
383 HiChecker::InitHicheckerParam(processName);
384 ASSERT_FALSE(HiChecker::Contains(Rule::RULE_CHECK_ARKUI_PERFORMANCE));
385 }
386 } // namespace HiviewDFX
387 } // namespace OHOS
388