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 #include <iostream>
16
17 #include <gtest/gtest.h>
18
19 #include "app_event.h"
20 #include "hiappevent_base.h"
21 #include "hiappevent_config.h"
22
23 using namespace testing::ext;
24 using namespace OHOS::HiviewDFX;
25 using namespace OHOS::HiviewDFX::ErrorCode;
26 using namespace OHOS::HiviewDFX::HiAppEvent;
27
28 namespace {
29 const std::string TEST_DIR = "/data/test/hiappevent/";
30 const std::string TEST_DOMAIN = "test_domain";
31 const std::string TEST_NAME = "test_domain";
32 const EventType TEST_TYPE = FAULT;
33 constexpr int32_t TEST_INT_VALUE = 1;
34 const std::string TEST_STR_VALUE = "test_value";
35 constexpr int32_t TEST_UID = 200000 * 100;
36
37 class HiAppEventAppEventTest : public testing::Test {
38 public:
39 void SetUp();
40 void TearDown();
41 };
42
SetUp()43 void HiAppEventAppEventTest::SetUp()
44 {
45 // set app uid
46 setuid(TEST_UID);
47 HiAppEventConfig::GetInstance().SetStorageDir(TEST_DIR);
48 }
49
TearDown()50 void HiAppEventAppEventTest::TearDown()
51 {}
52 }
53
54 /**
55 * @tc.name: HiAppEventAppEventTest001
56 * @tc.desc: Test the writing of normal data.
57 * @tc.type: FUNC
58 */
59 HWTEST_F(HiAppEventAppEventTest, HiAppEventAppEventTest001, TestSize.Level1)
60 {
61 std::cout << "HiAppEventAppEventTest001 start" << std::endl;
62
63 Event event(TEST_DOMAIN, TEST_NAME, FAULT);
64 event.AddParam("Bool_key", true);
65 constexpr int32_t num1 = 1;
66 event.AddParam("int32_key", num1);
67 constexpr int64_t num2 = 1;
68 event.AddParam("$int64_key", num2);
69 constexpr double num3 = 123.456;
70 event.AddParam("dou_key1", num3);
71 event.AddParam("str_key", TEST_STR_VALUE);
72
73 const std::vector<bool> bs = {false, true};
74 event.AddParam("bools_key", bs);
75 const std::vector<int32_t> num1s = {INT32_MAX, INT32_MIN};
76 event.AddParam("int32s_key", num1s);
77 const std::vector<int64_t> num2s = {INT64_MAX, INT64_MIN};
78 event.AddParam("$int64s_key", num2s);
79 const std::vector<double> num3s = {123.456, 234.67890123};
80 event.AddParam("double_key", num3s);
81 const std::vector<std::string> strs = {TEST_STR_VALUE, TEST_STR_VALUE};
82 event.AddParam("strs_key", strs);
83
84 int ret = Write(event);
85 ASSERT_EQ(ret, HIAPPEVENT_VERIFY_SUCCESSFUL);
86
87 std::cout << "HiAppEventAppEventTest001 end" << std::endl;
88 }
89
90 /**
91 * @tc.name: HiAppEventAppEventTest002
92 * @tc.desc: Test the writing of invalid param name.
93 * @tc.type: FUNC
94 */
95 HWTEST_F(HiAppEventAppEventTest, HiAppEventAppEventTest002, TestSize.Level1)
96 {
97 std::cout << "HiAppEventAppEventTest001 start" << std::endl;
98
99 Event event1(TEST_DOMAIN, TEST_NAME, FAULT);
100 event1.AddParam("**", TEST_INT_VALUE);
101 ASSERT_EQ(Write(event1), ERROR_INVALID_PARAM_NAME);
102 Event event2(TEST_DOMAIN, TEST_NAME, STATISTIC);
103 event2.AddParam("aa_", TEST_INT_VALUE);
104 ASSERT_EQ(Write(event2), ERROR_INVALID_PARAM_NAME);
105 Event event3(TEST_DOMAIN, TEST_NAME, SECURITY);
106 event3.AddParam("", TEST_INT_VALUE);
107 ASSERT_EQ(Write(event3), ERROR_INVALID_PARAM_NAME);
108 Event event4(TEST_DOMAIN, TEST_NAME, BEHAVIOR);
109 event4.AddParam("123AAA", TEST_INT_VALUE);
110 ASSERT_EQ(Write(event4), ERROR_INVALID_PARAM_NAME);
111
112 constexpr size_t limitLen = 32;
113 Event event5(TEST_DOMAIN, TEST_NAME, BEHAVIOR);
114 event5.AddParam(std::string(limitLen, 'a'), TEST_INT_VALUE);
115 ASSERT_EQ(Write(event5), HIAPPEVENT_VERIFY_SUCCESSFUL);
116 Event event6(TEST_DOMAIN, TEST_NAME, BEHAVIOR);
117 event6.AddParam(std::string(limitLen + 1, 'a'), TEST_INT_VALUE);
118 ASSERT_EQ(Write(event6), ERROR_INVALID_PARAM_NAME);
119 Event event7(TEST_DOMAIN, TEST_NAME, BEHAVIOR);
120 event7.AddParam(std::string(limitLen - 1, 'a') + "_", TEST_INT_VALUE);
121 ASSERT_EQ(Write(event7), ERROR_INVALID_PARAM_NAME);
122
123 std::cout << "HiAppEventAppEventTest002 end" << std::endl;
124 }
125
126 /**
127 * @tc.name: HiAppEventAppEventTest003
128 * @tc.desc: Test the writing of invalid length string.
129 * @tc.type: FUNC
130 */
131 HWTEST_F(HiAppEventAppEventTest, HiAppEventAppEventTest003, TestSize.Level1)
132 {
133 std::cout << "HiAppEventAppEventTest003 start" << std::endl;
134
135 constexpr size_t maxStrLen = 8 * 1024;
136 std::string longStr(maxStrLen, 'a');
137 Event event1(TEST_DOMAIN, TEST_NAME, TEST_TYPE);
138 event1.AddParam("str_key", longStr);
139 ASSERT_EQ(Write(event1), HIAPPEVENT_VERIFY_SUCCESSFUL);
140
141 std::string longInvalidStr(maxStrLen + 1, 'a');
142 Event event2(TEST_DOMAIN, TEST_NAME, TEST_TYPE);
143 event2.AddParam("str_key", longInvalidStr);
144 ASSERT_EQ(Write(event2), ERROR_INVALID_PARAM_VALUE_LENGTH);
145
146 Event event3(TEST_DOMAIN, TEST_NAME, TEST_TYPE);
147 const std::vector<std::string> strs1 = {longStr};
148 event3.AddParam("strs_key", strs1);
149 ASSERT_EQ(Write(event3), HIAPPEVENT_VERIFY_SUCCESSFUL);
150
151 Event event4(TEST_DOMAIN, TEST_NAME, TEST_TYPE);
152 const std::vector<std::string> strs2 = {longInvalidStr};
153 event4.AddParam("strs_key", strs2);
154 ASSERT_EQ(Write(event4), ERROR_INVALID_PARAM_VALUE_LENGTH);
155
156 std::cout << "HiAppEventAppEventTest003 end" << std::endl;
157 }
158
159 /**
160 * @tc.name: HiAppEventAppEventTest004
161 * @tc.desc: Test the writing of invalid number of params.
162 * @tc.type: FUNC
163 */
164 HWTEST_F(HiAppEventAppEventTest, HiAppEventAppEventTest004, TestSize.Level1)
165 {
166 std::cout << "HiAppEventAppEventTest004 start" << std::endl;
167
168 constexpr size_t limitLen = 32;
169 std::vector<std::string> keys(limitLen + 1);
170 std::vector<std::string> values(limitLen + 1);
171 Event event1(TEST_DOMAIN, TEST_NAME, TEST_TYPE);
172 for (size_t i = 0; i <= limitLen; i++) {
173 keys[i] = "key" + std::to_string(i);
174 values[i] = "value" + std::to_string(i);
175 event1.AddParam(keys[i], values[i]);
176 }
177 ASSERT_EQ(Write(event1), ERROR_INVALID_PARAM_NUM);
178
179 Event event2(TEST_DOMAIN, TEST_NAME, TEST_TYPE);
180 ASSERT_EQ(Write(event2), HIAPPEVENT_VERIFY_SUCCESSFUL);
181
182 Event event3(TEST_DOMAIN, TEST_NAME, TEST_TYPE);
183 for (size_t i = 0; i < limitLen; i++) {
184 event3.AddParam(keys[i], values[i]);
185 }
186 ASSERT_EQ(Write(event3), HIAPPEVENT_VERIFY_SUCCESSFUL);
187
188 std::cout << "HiAppEventAppEventTest004 end" << std::endl;
189 }
190
191 /**
192 * @tc.name: HiAppEventAppEventTest005
193 * @tc.desc: Test the writing of invalid event name.
194 * @tc.type: FUNC
195 */
196 HWTEST_F(HiAppEventAppEventTest, HiAppEventAppEventTest005, TestSize.Level1)
197 {
198 std::cout << "HiAppEventAppEventTest005 start" << std::endl;
199
200 Event event(TEST_DOMAIN, "$event", TEST_TYPE);
201 ASSERT_EQ(Write(event), HIAPPEVENT_VERIFY_SUCCESSFUL);
202
203 Event event1(TEST_DOMAIN, "verify_**", TEST_TYPE);
204 ASSERT_EQ(Write(event1), ERROR_INVALID_EVENT_NAME);
205 Event event2(TEST_DOMAIN, "aa_", TEST_TYPE);
206 ASSERT_EQ(Write(event1), ERROR_INVALID_EVENT_NAME);
207 Event event3(TEST_DOMAIN, "123AAA", TEST_TYPE);
208 ASSERT_EQ(Write(event3), ERROR_INVALID_EVENT_NAME);
209 Event event4(TEST_DOMAIN, "", TEST_TYPE);
210 ASSERT_EQ(Write(event4), ERROR_INVALID_EVENT_NAME);
211
212 constexpr size_t limitLen = 48;
213 Event event5(TEST_DOMAIN, std::string(limitLen, 'a'), BEHAVIOR);
214 ASSERT_EQ(Write(event5), HIAPPEVENT_VERIFY_SUCCESSFUL);
215 Event event6(TEST_DOMAIN, std::string(limitLen + 1, 'a'), BEHAVIOR);
216 ASSERT_EQ(Write(event6), ERROR_INVALID_EVENT_NAME);
217
218 std::cout << "HiAppEventAppEventTest005 end" << std::endl;
219 }
220
221 /**
222 * @tc.name: HiAppEventAppEventTest006
223 * @tc.desc: Test the writing of invalid domain name.
224 * @tc.type: FUNC
225 */
226 HWTEST_F(HiAppEventAppEventTest, HiAppEventAppEventTest006, TestSize.Level1)
227 {
228 std::cout << "HiAppEventAppEventTest006 start" << std::endl;
229
230 Event event("domain_123_a", TEST_NAME, TEST_TYPE);
231 ASSERT_EQ(Write(event), HIAPPEVENT_VERIFY_SUCCESSFUL);
232
233 Event event1("Domain", TEST_NAME, TEST_TYPE);
234 ASSERT_EQ(Write(event1), HIAPPEVENT_VERIFY_SUCCESSFUL);
235 Event event2("123_domain", TEST_NAME, TEST_TYPE);
236 ASSERT_EQ(Write(event2), ERROR_INVALID_EVENT_DOMAIN);
237 Event event3("domain**", TEST_NAME, TEST_TYPE);
238 ASSERT_EQ(Write(event3), ERROR_INVALID_EVENT_DOMAIN);
239 Event event4("domain_", TEST_NAME, TEST_TYPE);
240 ASSERT_EQ(Write(event4), ERROR_INVALID_EVENT_DOMAIN);
241
242 constexpr size_t limitLen = 32;
243 Event event5(std::string(limitLen, 'a'), TEST_NAME, BEHAVIOR);
244 ASSERT_EQ(Write(event5), HIAPPEVENT_VERIFY_SUCCESSFUL);
245 Event event6(std::string(limitLen + 1, 'a'), TEST_NAME, BEHAVIOR);
246 ASSERT_EQ(Write(event6), ERROR_INVALID_EVENT_DOMAIN);
247 Event event7("", TEST_NAME, BEHAVIOR);
248 ASSERT_EQ(Write(event7), ERROR_INVALID_EVENT_DOMAIN);
249 Event event8(std::string(limitLen - 1, 'a') + "_", TEST_NAME, BEHAVIOR);
250 ASSERT_EQ(Write(event8), ERROR_INVALID_EVENT_DOMAIN);
251
252 std::cout << "HiAppEventAppEventTest006 end" << std::endl;
253 }
254
255 /**
256 * @tc.name: HiAppEventAppEventTest007
257 * @tc.desc: Test the writing of invalid vector size.
258 * @tc.type: FUNC
259 */
260 HWTEST_F(HiAppEventAppEventTest, HiAppEventAppEventTest007, TestSize.Level1)
261 {
262 std::cout << "HiAppEventAppEventTest007 start" << std::endl;
263
264 Event event1(TEST_DOMAIN, TEST_NAME, TEST_TYPE);
265 constexpr size_t limitSize = 100;
266 std::vector<int32_t> nums1(limitSize, TEST_INT_VALUE);
267 event1.AddParam("valid_vec", nums1);
268 ASSERT_EQ(Write(event1), HIAPPEVENT_VERIFY_SUCCESSFUL);
269
270 Event event2(TEST_DOMAIN, TEST_NAME, TEST_TYPE);
271 std::vector<int32_t> nums2(limitSize + 1, TEST_INT_VALUE);
272 event2.AddParam("invalid_vec", nums2);
273 ASSERT_EQ(Write(event2), ERROR_INVALID_LIST_PARAM_SIZE);
274
275 std::cout << "HiAppEventAppEventTest007 end" << std::endl;
276 }
277
278 /**
279 * @tc.name: HiAppEventAppEventTest008
280 * @tc.desc: Test the writing of logging function disabled.
281 * @tc.type: FUNC
282 */
283 HWTEST_F(HiAppEventAppEventTest, HiAppEventAppEventTest008, TestSize.Level1)
284 {
285 std::cout << "HiAppEventAppEventTest008 start" << std::endl;
286
287 HiAppEventConfig::GetInstance().SetConfigurationItem("disable", "false");
288 Event event(TEST_DOMAIN, TEST_NAME, TEST_TYPE);
289 ASSERT_EQ(Write(event), HIAPPEVENT_VERIFY_SUCCESSFUL);
290
291 HiAppEventConfig::GetInstance().SetConfigurationItem("disable", "true");
292 ASSERT_EQ(Write(event), ERROR_HIAPPEVENT_DISABLE);
293
294 HiAppEventConfig::GetInstance().SetConfigurationItem("disable", "false");
295 ASSERT_EQ(Write(event), HIAPPEVENT_VERIFY_SUCCESSFUL);
296
297 std::cout << "HiAppEventAppEventTest008 end" << std::endl;
298 }
299
300 /**
301 * @tc.name: HiAppEventAppEventTest009
302 * @tc.desc: Test the writing of duplicate param.
303 * @tc.type: FUNC
304 */
305 HWTEST_F(HiAppEventAppEventTest, HiAppEventAppEventTest009, TestSize.Level1)
306 {
307 std::cout << "HiAppEventAppEventTest009 start" << std::endl;
308
309 Event event1(TEST_DOMAIN, TEST_NAME, TEST_TYPE);
310 std::vector<std::string> strs = {TEST_STR_VALUE};
311 event1.AddParam("str_key", strs);
312 ASSERT_EQ(Write(event1), HIAPPEVENT_VERIFY_SUCCESSFUL);
313 event1.AddParam("str_key", TEST_STR_VALUE);
314 ASSERT_EQ(Write(event1), ERROR_DUPLICATE_PARAM);
315
316 std::cout << "HiAppEventAppEventTest009 end" << std::endl;
317 }
318
319 /**
320 * @tc.name: HiAppEventAppEventTest010
321 * @tc.desc: Test the writing of not app.
322 * @tc.type: FUNC
323 */
324 HWTEST_F(HiAppEventAppEventTest, HiAppEventAppEventTest010, TestSize.Level1)
325 {
326 std::cout << "HiAppEventAppEventTest010 start" << std::endl;
327
328 setuid(0); // 0 means root uid
329 Event event(TEST_DOMAIN, TEST_NAME, FAULT);
330 int ret = Write(event);
331 ASSERT_EQ(ret, ERROR_NOT_APP);
332
333 setuid(TEST_UID);
334 ret = Write(event);
335 ASSERT_EQ(ret, HIAPPEVENT_VERIFY_SUCCESSFUL);
336
337 std::cout << "HiAppEventAppEventTest010 end" << std::endl;
338 }
339