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 <ctime>
17 #include <gtest/gtest.h>
18
19 #include "caution.h"
20 #include "hichecker.h"
21
22 using namespace testing::ext;
23 using namespace OHOS::HiviewDFX;
24
25 namespace {
26 const int64_t SEC_TO_NS = 1000000000;
27 const int64_t MAX_CALL_DURATION_US = 1000; // 1ms
28 const int LOOP_COUNT = 1000;
29 const uint64_t RULE_ERROR0 = 0;
30 const uint64_t RULE_ERROR1 = -1;
31 const uint64_t RULE_ERROR2 = 999999999;
32 }
33
34 class HiCheckerNativeTest : public testing::Test {
35 public:
SerUpTestCase()36 static void SerUpTestCase() {};
TearDownTestCase()37 static void TearDownTestCase() {};
38 void SetUp();
39 void TearDown();
40 };
41
SetUp(void)42 void HiCheckerNativeTest::SetUp(void)
43 {
44 HiChecker::RemoveRule(Rule::ALL_RULES);
45 }
46
TearDown(void)47 void HiCheckerNativeTest::TearDown(void)
48 {
49 HiChecker::RemoveRule(Rule::ALL_RULES);
50 }
51
GetTimeNs()52 static int64_t GetTimeNs()
53 {
54 struct timespec ts;
55 clock_gettime(CLOCK_REALTIME, &ts);
56 return ts.tv_sec * SEC_TO_NS + ts.tv_nsec;
57 }
58
59 /**
60 * @tc.name: AddRule001
61 * @tc.desc: add only one rule
62 * @tc.type: FUNC
63 */
64 HWTEST_F(HiCheckerNativeTest, AddRuleTest001, TestSize.Level1)
65 {
66 uint64_t rule = Rule::RULE_THREAD_CHECK_SLOW_PROCESS;
67 HiChecker::AddRule(Rule::RULE_THREAD_CHECK_SLOW_PROCESS);
68 ASSERT_EQ(HiChecker::GetRule(), rule);
69 rule |= Rule::RULE_CAUTION_PRINT_LOG;
70 HiChecker::AddRule(Rule::RULE_CAUTION_PRINT_LOG);
71 ASSERT_EQ(HiChecker::GetRule(), rule);
72 }
73
74 /**
75 * @tc.name: AddRule002
76 * @tc.desc: add two or more rules
77 * @tc.type: FUNC
78 */
79 HWTEST_F(HiCheckerNativeTest, AddRuleTest002, TestSize.Level1)
80 {
81 uint64_t rule = Rule::RULE_THREAD_CHECK_SLOW_PROCESS |
82 Rule::RULE_CHECK_SLOW_EVENT | Rule::RULE_CHECK_ABILITY_CONNECTION_LEAK;
83 HiChecker::AddRule(Rule::RULE_THREAD_CHECK_SLOW_PROCESS |
84 Rule::RULE_CHECK_SLOW_EVENT | Rule::RULE_CHECK_ABILITY_CONNECTION_LEAK);
85 ASSERT_EQ(HiChecker::GetRule(), rule);
86 rule |= (Rule::RULE_CAUTION_PRINT_LOG | Rule::RULE_CAUTION_TRIGGER_CRASH);
87 HiChecker::AddRule(Rule::RULE_CAUTION_PRINT_LOG | Rule::RULE_CAUTION_TRIGGER_CRASH);
88 ASSERT_EQ(HiChecker::GetRule(), rule);
89 }
90
91 /**
92 * @tc.name: AddRule003
93 * @tc.desc: add invaild rule
94 * @tc.type: FUNC
95 */
96 HWTEST_F(HiCheckerNativeTest, AddRuleTest003, TestSize.Level1)
97 {
98 HiChecker::AddRule(RULE_ERROR0);
99 ASSERT_EQ(HiChecker::GetRule(), 0);
100 HiChecker::AddRule(RULE_ERROR1);
101 ASSERT_EQ(HiChecker::GetRule(), 0);
102 HiChecker::AddRule(RULE_ERROR2);
103 ASSERT_EQ(HiChecker::GetRule(), 0);
104 }
105
106 /**
107 * @tc.name: AddRulePerf
108 * @tc.desc: test performance for AddRule
109 * @tc.type: PERF
110 */
111 HWTEST_F(HiCheckerNativeTest, AddRulePerfTest001, TestSize.Level2)
112 {
113 int64_t total = 0;
114 for (int i = 0; i < LOOP_COUNT; i++) {
115 int64_t start = GetTimeNs();
116 HiChecker::AddRule(Rule::RULE_CHECK_SLOW_EVENT);
117 int64_t duration = GetTimeNs() - start;
118 total += duration;
119 }
120 int64_t duration = (total / LOOP_COUNT);
121 duration = duration / 1000;
122 ASSERT_TRUE(duration < MAX_CALL_DURATION_US);
123 }
124
125 /**
126 * @tc.name: RemoveRule001
127 * @tc.desc: remove only one rule
128 * @tc.type: FUNC
129 */
130 HWTEST_F(HiCheckerNativeTest, RemoveRuleTest001, TestSize.Level1)
131 {
132 HiChecker::AddRule(Rule::ALL_RULES);
133 HiChecker::RemoveRule(Rule::RULE_CAUTION_TRIGGER_CRASH);
134 ASSERT_FALSE(HiChecker::Contains(Rule::RULE_CAUTION_TRIGGER_CRASH));
135 HiChecker::RemoveRule(Rule::RULE_CAUTION_PRINT_LOG);
136 ASSERT_FALSE(HiChecker::Contains(Rule::RULE_CAUTION_PRINT_LOG));
137 uint64_t rule = Rule::ALL_RULES ^ (Rule::RULE_CAUTION_PRINT_LOG | Rule::RULE_CAUTION_TRIGGER_CRASH);
138 ASSERT_EQ(HiChecker::GetRule(), rule);
139 }
140
141 /**
142 * @tc.name: RemoveRule002
143 * @tc.desc: remove two or more rules
144 * @tc.type: FUNC
145 */
146 HWTEST_F(HiCheckerNativeTest, RemoveRuleTest002, TestSize.Level1)
147 {
148 HiChecker::AddRule(Rule::ALL_RULES);
149 HiChecker::RemoveRule(Rule::RULE_CAUTION_TRIGGER_CRASH | Rule::RULE_CAUTION_PRINT_LOG);
150 ASSERT_FALSE(HiChecker::Contains(Rule::RULE_CAUTION_TRIGGER_CRASH));
151 ASSERT_FALSE(HiChecker::Contains(Rule::RULE_CAUTION_PRINT_LOG));
152 uint64_t rule = Rule::ALL_RULES ^ (Rule::RULE_CAUTION_PRINT_LOG | Rule::RULE_CAUTION_TRIGGER_CRASH);
153 ASSERT_EQ(HiChecker::GetRule(), rule);
154 }
155
156 /**
157 * @tc.name: RemoveRule003
158 * @tc.desc: remove invaild rule
159 * @tc.type: FUNC
160 */
161 HWTEST_F(HiCheckerNativeTest, RemoveRuleTest003, TestSize.Level1)
162 {
163 HiChecker::AddRule(Rule::ALL_RULES);
164 HiChecker::RemoveRule(RULE_ERROR0);
165 ASSERT_EQ(HiChecker::GetRule(), Rule::ALL_RULES);
166 HiChecker::RemoveRule(RULE_ERROR1);
167 ASSERT_EQ(HiChecker::GetRule(), Rule::ALL_RULES);
168 HiChecker::RemoveRule(RULE_ERROR2);
169 ASSERT_EQ(HiChecker::GetRule(), Rule::ALL_RULES);
170 }
171
172 /**
173 * @tc.name: RemoveRulePerf
174 * @tc.desc: test performance for RemoveRule
175 * @tc.type: PERF
176 */
177 HWTEST_F(HiCheckerNativeTest, RemoveRulePerfTest001, TestSize.Level2)
178 {
179 int64_t total = 0;
180 for (int i = 0; i < LOOP_COUNT; i++) {
181 int64_t start = GetTimeNs();
182 HiChecker::RemoveRule(Rule::RULE_CHECK_SLOW_EVENT);
183 int64_t duration = GetTimeNs() - start;
184 total += duration;
185 }
186 int64_t duration = (total / LOOP_COUNT);
187 duration = duration / 1000;
188 ASSERT_TRUE(duration < MAX_CALL_DURATION_US);
189 }
190
191 /**
192 * @tc.name: Contains001
193 * @tc.desc: test Contains
194 * @tc.type: FUNC
195 */
196 HWTEST_F(HiCheckerNativeTest, ContainsTest001, TestSize.Level1)
197 {
198 HiChecker::AddRule(Rule::RULE_CAUTION_PRINT_LOG);
199 ASSERT_TRUE(HiChecker::Contains(Rule::RULE_CAUTION_PRINT_LOG));
200 ASSERT_FALSE(HiChecker::Contains(Rule::RULE_CAUTION_TRIGGER_CRASH));
201 ASSERT_FALSE(HiChecker::Contains(Rule::RULE_CAUTION_PRINT_LOG | Rule::RULE_CAUTION_TRIGGER_CRASH));
202 }
203
204 /**
205 * @tc.name: Contains002
206 * @tc.desc: test Contains with invaild rule
207 * @tc.type: FUNC
208 */
209 HWTEST_F(HiCheckerNativeTest, ContainsTest002, TestSize.Level1)
210 {
211 HiChecker::AddRule(Rule::ALL_RULES);
212 ASSERT_FALSE(HiChecker::Contains(RULE_ERROR0));
213 ASSERT_FALSE(HiChecker::Contains(RULE_ERROR1));
214 ASSERT_FALSE(HiChecker::Contains(RULE_ERROR2));
215 }
216
217 /**
218 * @tc.name: CautionTest001
219 * @tc.desc: test Caution
220 * @tc.type: FUNC
221 */
222 HWTEST_F(HiCheckerNativeTest, CautionTest001, TestSize.Level1)
223 {
224 Caution caution;
225 caution.SetTriggerRule(Rule::RULE_CAUTION_PRINT_LOG);
226 EXPECT_EQ(caution.GetTriggerRule(), Rule::RULE_CAUTION_PRINT_LOG);
227
228 caution.SetStackTrace("stack_trace");
229 EXPECT_EQ(caution.GetStackTrace(), "stack_trace");
230 }