1 /*
2  * Copyright (c) 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_easy_test.h"
17 
18 #include "easy_def.h"
19 #include "easy_event_builder.h"
20 #include "easy_event_encoder.h"
21 #include "easy_socket_writer.h"
22 #include "easy_util.h"
23 #include "hisysevent_easy.h"
24 
25 using namespace testing::ext;
26 
SetUp()27 void HiSysEventEasyTest::SetUp()
28 {}
29 
TearDown()30 void HiSysEventEasyTest::TearDown()
31 {}
32 
33 /**
34  * @tc.name: HiSysEventEasyTest001
35  * @tc.desc: Test writing event with valid content.
36  * @tc.type: FUNC
37  * @tc.require: issueIAKQGU
38  */
HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest001, TestSize.Level3)39 HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest001, TestSize.Level3)
40 {
41     int ret = OH_HiSysEvent_Easy_Write("KERNEL_VENDOR", "POWER_KEY", EASY_EVENT_TYPE_FAULT, "TEST_DATA");
42     ASSERT_EQ(ret, SUCCESS);
43 }
44 
45 /**
46  * @tc.name: HiSysEventEasyTest002
47  * @tc.desc: Test writing event with invalid domain.
48  * @tc.type: FUNC
49  * @tc.require: issueIAKQGU
50  */
HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest002, TestSize.Level3)51 HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest002, TestSize.Level3)
52 {
53     // write null domain
54     int ret = OH_HiSysEvent_Easy_Write(nullptr, "POWER_KEY", EASY_EVENT_TYPE_FAULT, "TEST_DATA");
55     ASSERT_EQ(ret, ERR_DOMAIN_INVALID);
56     // length of domain is too long
57     ret = OH_HiSysEvent_Easy_Write("KERNEL_VENDORKERNEL_VENDOR", "POWER_KEY", EASY_EVENT_TYPE_FAULT, "TEST_DATA");
58     ASSERT_EQ(ret, ERR_DOMAIN_INVALID);
59 }
60 
61 /**
62  * @tc.name: HiSysEventEasyTest003
63  * @tc.desc: Test writing event with different event type.
64  * @tc.type: FUNC
65  * @tc.require: issueIAKQGU
66  */
HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest003, TestSize.Level3)67 HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest003, TestSize.Level3)
68 {
69     // event type which value is lower than 1
70     enum HiSysEventEasyType invalidType = (enum HiSysEventEasyType)0;
71     int ret = OH_HiSysEvent_Easy_Write("KERNEL_VENDOR", "POWER_KEY", invalidType, "TEST_DATA"); // 0 is invalid type
72     ASSERT_EQ(ret, ERR_TYPE_INVALID);
73     // event type which value is greater than 4
74     invalidType = (enum HiSysEventEasyType)5;
75     ret = OH_HiSysEvent_Easy_Write("KERNEL_VENDOR", "POWER_KEY", invalidType, "TEST_DATA");
76     ASSERT_EQ(ret, ERR_TYPE_INVALID);
77     // write event with fault type
78     ret = OH_HiSysEvent_Easy_Write("KERNEL_VENDOR", "POWER_KEY", EASY_EVENT_TYPE_FAULT, "TEST_DATA");
79     ASSERT_EQ(ret, SUCCESS);
80     // write event with statistic type
81     ret = OH_HiSysEvent_Easy_Write("KERNEL_VENDOR", "POWER_KEY", EASY_EVENT_TYPE_STATISTIC, "TEST_DATA");
82     ASSERT_EQ(ret, SUCCESS);
83     // write event with security type
84     ret = OH_HiSysEvent_Easy_Write("KERNEL_VENDOR", "POWER_KEY", EASY_EVENT_TYPE_SECURITY, "TEST_DATA");
85     ASSERT_EQ(ret, SUCCESS);
86     // write event with behavior type
87     ret = OH_HiSysEvent_Easy_Write("KERNEL_VENDOR", "POWER_KEY", EASY_EVENT_TYPE_BEHAVIOR, "TEST_DATA");
88     ASSERT_EQ(ret, SUCCESS);
89 }
90 
91 /**
92  * @tc.name: HiSysEventEasyTest004
93  * @tc.desc: Test writing event with invalid name.
94  * @tc.type: FUNC
95  * @tc.require: issueIAKQGU
96  */
HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest004, TestSize.Level3)97 HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest004, TestSize.Level3)
98 {
99     // write null name
100     int ret = OH_HiSysEvent_Easy_Write("KERNEL_VENDOR", nullptr, EASY_EVENT_TYPE_FAULT, "TEST_DATA");
101     ASSERT_EQ(ret, ERR_NAME_INVALID);
102     // length of name is too long
103     ret = OH_HiSysEvent_Easy_Write("KERNEL_VENDOR", "POWER_KEYPOWER_KEYPOWER_KEYPOWER_KEY", EASY_EVENT_TYPE_FAULT,
104         "TEST_DATA");
105     ASSERT_EQ(ret, ERR_NAME_INVALID);
106 }
107 
108 /**
109  * @tc.name: HiSysEventEasyTest005
110  * @tc.desc: Test writing event with invalid customized string.
111  * @tc.type: FUNC
112  * @tc.require: issueIAKQGU
113  */
HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest005, TestSize.Level3)114 HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest005, TestSize.Level3)
115 {
116     // write a string with 1025 bytes
117     std::string strContent;
118     for (int i = 0; i < 102; i++) {
119         strContent = strContent + std::string("0123456789");
120     }
121     strContent = strContent + "01234";
122     int ret = OH_HiSysEvent_Easy_Write("KERNEL_VENDOR", "POWER_KEY", EASY_EVENT_TYPE_FAULT, strContent.c_str());
123     ASSERT_EQ(ret, ERR_PARAM_VALUE_INVALID);
124     // write null string
125     ret = OH_HiSysEvent_Easy_Write("KERNEL_VENDOR", "POWER_KEY", EASY_EVENT_TYPE_FAULT, nullptr);
126     ASSERT_EQ(ret, ERR_PARAM_VALUE_INVALID);
127 }
128 
129 /**
130  * @tc.name: HiSysEventEasyTest006
131  * @tc.desc: Test AppendHeader
132  * @tc.type: FUNC
133  * @tc.require: issueIAKQGU
134  */
HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest006, TestSize.Level3)135 HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest006, TestSize.Level3)
136 {
137     size_t offset = 0;
138     struct HiSysEventEasyHeader header;
139     int ret = MemoryInit((uint8_t*)(&header), sizeof(struct HiSysEventEasyHeader));
140     ASSERT_EQ(ret, SUCCESS);
141     ret = AppendHeader(nullptr, EVENT_BUFF_LEN, &offset, &header);
142     ASSERT_EQ(ret, ERR_EVENT_BUF_INVALID);
143     const int eventBufLen = 100;
144     uint8_t testEventBuff[eventBufLen];
145     ret = AppendHeader(testEventBuff, EVENT_BUFF_LEN, nullptr, &header);
146     ASSERT_EQ(ret, ERR_EVENT_BUF_INVALID);
147     ret = AppendHeader(testEventBuff, EVENT_BUFF_LEN, &offset, nullptr);
148     ASSERT_EQ(ret, ERR_EVENT_BUF_INVALID);
149     offset = EVENT_BUFF_LEN - 2; // 2 is a test value
150     ret = AppendHeader(testEventBuff, EVENT_BUFF_LEN, &offset, &header);
151     ASSERT_EQ(ret, ERR_MEM_OPT_FAILED);
152     offset = 0;
153     ret = AppendHeader(testEventBuff, EVENT_BUFF_LEN, &offset, &header);
154     ASSERT_EQ(ret, SUCCESS);
155 }
156 
157 /**
158  * @tc.name: HiSysEventEasyTest007
159  * @tc.desc: Test AppendStringParam
160  * @tc.type: FUNC
161  * @tc.require: issueIAKQGU
162  */
HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest007, TestSize.Level3)163 HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest007, TestSize.Level3)
164 {
165     size_t offset = 0;
166     int ret = AppendStringParam(nullptr, EVENT_BUFF_LEN, &offset, nullptr, nullptr);
167     ASSERT_EQ(ret, ERR_EVENT_BUF_INVALID);
168     uint8_t testEventBuff[EVENT_BUFF_LEN];
169     ret = AppendStringParam(testEventBuff, EVENT_BUFF_LEN, nullptr, nullptr, nullptr);
170     ASSERT_EQ(ret, ERR_EVENT_BUF_INVALID);
171     ret = AppendStringParam(testEventBuff, EVENT_BUFF_LEN, &offset, nullptr, nullptr);
172     ASSERT_EQ(ret, ERR_EVENT_BUF_INVALID);
173     ret = AppendStringParam(testEventBuff, EVENT_BUFF_LEN, &offset, "TEST_KEY", nullptr);
174     ASSERT_EQ(ret, ERR_PARAM_VALUE_INVALID);
175     offset = EVENT_BUFF_LEN;
176     ret = AppendStringParam(testEventBuff, EVENT_BUFF_LEN, &offset, "TEST_KEY", "TEST_VAL");
177     ASSERT_EQ(ret, ERR_ENCODE_STR_FAILED);
178     offset = EVENT_BUFF_LEN - 9; // 9 is a test value
179     ret = AppendStringParam(testEventBuff, EVENT_BUFF_LEN, &offset, "TEST_KEY", "TEST_VAL");
180     ASSERT_EQ(ret, ERR_ENCODE_VALUE_TYPE_FAILED);
181     offset = 0;
182     ret = AppendStringParam(testEventBuff, EVENT_BUFF_LEN, &offset, "TEST_KEY", "TEST_VAL");
183     ASSERT_EQ(ret, SUCCESS);
184 }
185 
186 /**
187  * @tc.name: HiSysEventEasyTest008
188  * @tc.desc: Test EncodeValueType
189  * @tc.type: FUNC
190  * @tc.require: issueIAKQGU
191  */
HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest008, TestSize.Level3)192 HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest008, TestSize.Level3)
193 {
194     size_t offset = 0;
195     struct HiSysEventEasyParamValueType valueType;
196     valueType.isArray = 0;
197     valueType.valueType = 0;
198     valueType.valueByteCnt = 0;
199     int ret = EncodeValueType(nullptr, EVENT_BUFF_LEN, &offset, &valueType);
200     ASSERT_EQ(ret, ERR_EVENT_BUF_INVALID);
201     uint8_t data[EVENT_BUFF_LEN];
202     ret = EncodeValueType(data, EVENT_BUFF_LEN, nullptr, &valueType);
203     ASSERT_EQ(ret, ERR_EVENT_BUF_INVALID);
204     ret = EncodeValueType(data, EVENT_BUFF_LEN, &offset, nullptr);
205     ASSERT_EQ(ret, ERR_EVENT_BUF_INVALID);
206     offset = EVENT_BUFF_LEN; // 2 is a test value
207     ret = EncodeValueType(data, EVENT_BUFF_LEN, &offset, &valueType);
208     ASSERT_EQ(ret, ERR_ENCODE_VALUE_TYPE_FAILED);
209     offset = 0;
210     ret = EncodeValueType(data, EVENT_BUFF_LEN, &offset, &valueType);
211     ASSERT_EQ(ret, SUCCESS);
212 }
213 
214 /**
215  * @tc.name: HiSysEventEasyTest009
216  * @tc.desc: Test EncodeStringValue
217  * @tc.type: FUNC
218  * @tc.require: issueIAKQGU
219  */
HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest009, TestSize.Level3)220 HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest009, TestSize.Level3)
221 {
222     size_t offset = 0;
223     int ret = EncodeStringValue(nullptr, EVENT_BUFF_LEN, &offset, nullptr);
224     ASSERT_EQ(ret, ERR_EVENT_BUF_INVALID);
225     uint8_t data[EVENT_BUFF_LEN];
226     ret = EncodeStringValue(data, EVENT_BUFF_LEN, nullptr, nullptr);
227     ASSERT_EQ(ret, ERR_EVENT_BUF_INVALID);
228     ret = EncodeStringValue(data, EVENT_BUFF_LEN, &offset, nullptr);
229     ASSERT_EQ(ret, ERR_EVENT_BUF_INVALID);
230     std::string val = "TEST";
231     offset = EVENT_BUFF_LEN - val.size() + 1; // 1 is a test value
232     ret = EncodeStringValue(data, EVENT_BUFF_LEN, &offset, val.c_str());
233     ASSERT_EQ(ret, ERR_ENCODE_STR_FAILED);
234     offset = EVENT_BUFF_LEN - val.size() + 3; // 3 is a test offset value
235     ret = EncodeStringValue(data, EVENT_BUFF_LEN, &offset, val.c_str());
236     ASSERT_EQ(ret, ERR_ENCODE_STR_FAILED);
237     offset = EVENT_BUFF_LEN - 30; // 30 is a test offset value
238     ret = EncodeStringValue(data, EVENT_BUFF_LEN, &offset, val.c_str());
239     ASSERT_EQ(ret, SUCCESS);
240     offset = 0;
241     ret = EncodeStringValue(data, EVENT_BUFF_LEN, &offset, val.c_str());
242     ASSERT_EQ(ret, SUCCESS);
243 }
244 
245 /**
246  * @tc.name: HiSysEventEasyTest010
247  * @tc.desc: Test Write
248  * @tc.type: FUNC
249  * @tc.require: issueIAKQGU
250  */
HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest010, TestSize.Level3)251 HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest010, TestSize.Level3)
252 {
253     int ret = Write(nullptr, 0);
254     ASSERT_EQ(ret, ERR_EVENT_BUF_INVALID);
255     uint8_t data[EVENT_BUFF_LEN];
256     ret = Write(data, EVENT_BUFF_LEN);
257     ASSERT_EQ(ret, SUCCESS);
258 }
259 
260 /**
261  * @tc.name: HiSysEventEasyTest011
262  * @tc.desc: Test MemoryInit
263  * @tc.type: FUNC
264  * @tc.require: issueIAKQGU
265  */
HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest011, TestSize.Level3)266 HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest011, TestSize.Level3)
267 {
268     int ret = MemoryInit(nullptr, 0);
269     ASSERT_EQ(ret, ERR_MEM_OPT_FAILED);
270     ret = MemoryInit(nullptr, EVENT_BUFF_LEN);
271     ASSERT_EQ(ret, ERR_MEM_OPT_FAILED);
272     uint8_t data[EVENT_BUFF_LEN];
273     ret = MemoryInit(data, EVENT_BUFF_LEN);
274     ASSERT_EQ(ret, SUCCESS);
275 }
276 
277 /**
278  * @tc.name: HiSysEventEasyTest012
279  * @tc.desc: Test MemoryCopy
280  * @tc.type: FUNC
281  * @tc.require: issueIAKQGU
282  */
HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest012, TestSize.Level3)283 HWTEST_F(HiSysEventEasyTest, HiSysEventEasyTest012, TestSize.Level3)
284 {
285     uint8_t data[EVENT_BUFF_LEN];
286     int ret = MemoryCopy(nullptr, 0, data, 0);
287     ASSERT_EQ(ret, ERR_MEM_OPT_FAILED);
288     ret = MemoryCopy(data, 0, nullptr, 0);
289     ASSERT_EQ(ret, ERR_MEM_OPT_FAILED);
290     uint8_t dataNew[EVENT_BUFF_LEN];
291     ret = MemoryCopy(data, EVENT_BUFF_LEN - 1, dataNew, EVENT_BUFF_LEN); // 1 is a test value
292     ASSERT_EQ(ret, ERR_MEM_OPT_FAILED);
293     ret = MemoryCopy(data, EVENT_BUFF_LEN, dataNew, EVENT_BUFF_LEN);
294     ASSERT_EQ(ret, SUCCESS);
295 }