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