1 /*
2  * Copyright (c) 2022-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 "gtest/gtest.h"
17 #include <securec.h>
18 #include "softbus_errcode.h"
19 #include "softbus_adapter_hisysevent.h"
20 
21 using namespace testing::ext;
22 
23 namespace OHOS {
24 
25 class AdapterDsoftbusDfxTest : public testing::Test {
26 protected:
SetUpTestCase()27     static void SetUpTestCase() {}
TearDownTestCase()28     static void TearDownTestCase() {}
SetUp()29     void SetUp() override {}
TearDown()30     void TearDown() override {}
31 };
32 
33 /*
34 * @tc.name: SoftbusWriteHisEvtTest001
35 * @tc.desc: ParamType is SOFTBUS_EVT_PARAMTYPE_BOOL
36 * @tc.type: FUNC
37 * @tc.require: 1
38 */
39 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusWriteHisEvtTest001, TestSize.Level1)
40 {
41     SoftBusEvtParam evtParam;
42     strcpy_s(evtParam.paramName, sizeof(evtParam.paramName), "testParamName");
43     evtParam.paramType = SOFTBUS_EVT_PARAMTYPE_BOOL;
44     evtParam.paramValue.b = false;
45 
46     SoftBusEvtReportMsg reportMsg;
47     reportMsg.evtType = SOFTBUS_EVT_TYPE_FAULT;
48     reportMsg.paramArray = &evtParam;
49     reportMsg.paramNum = 1;
50     strcpy_s(reportMsg.evtName, sizeof(evtParam.paramName), "testEvent");
51     int32_t ret = SoftbusWriteHisEvt(&reportMsg);
52     EXPECT_EQ(SOFTBUS_OK, ret);
53 }
54 
55 /*
56 * @tc.name: SoftbusWriteHisEvtTest002
57 * @tc.desc: ParamType is SOFTBUS_EVT_PARAMTYPE_UINT8
58 * @tc.type: FUNC
59 * @tc.require: 1
60 */
61 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusWriteHisEvtTest002, TestSize.Level1)
62 {
63     SoftBusEvtParam evtParam;
64     strcpy_s(evtParam.paramName, sizeof(evtParam.paramName), "testParamName");
65     evtParam.paramType = SOFTBUS_EVT_PARAMTYPE_UINT8;
66     evtParam.paramValue.u8v = UINT8_MAX;
67 
68     SoftBusEvtReportMsg reportMsg;
69     reportMsg.evtType = SOFTBUS_EVT_TYPE_FAULT;
70     reportMsg.paramArray = &evtParam;
71     reportMsg.paramNum = 1;
72     strcpy_s(reportMsg.evtName, sizeof(evtParam.paramName), "testEvent");
73     int32_t ret = SoftbusWriteHisEvt(&reportMsg);
74     EXPECT_EQ(SOFTBUS_OK, ret);
75 }
76 
77 /*
78 * @tc.name: SoftbusWriteHisEvtTest003
79 * @tc.desc: ParamType is SOFTBUS_EVT_PARAMTYPE_UINT16
80 * @tc.type: FUNC
81 * @tc.require: 1
82 */
83 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusWriteHisEvtTest003, TestSize.Level1)
84 {
85     SoftBusEvtParam evtParam;
86     strcpy_s(evtParam.paramName, sizeof(evtParam.paramName), "testParamName");
87     evtParam.paramType = SOFTBUS_EVT_PARAMTYPE_UINT16;
88     evtParam.paramValue.u16v = UINT16_MAX;
89 
90     SoftBusEvtReportMsg reportMsg;
91     reportMsg.evtType = SOFTBUS_EVT_TYPE_FAULT;
92     reportMsg.paramArray = &evtParam;
93     reportMsg.paramNum = 1;
94     strcpy_s(reportMsg.evtName, sizeof(evtParam.paramName), "testEvent");
95     int32_t ret = SoftbusWriteHisEvt(&reportMsg);
96     EXPECT_EQ(SOFTBUS_OK, ret);
97 }
98 
99 /*
100 * @tc.name: SoftbusWriteHisEvtTest004
101 * @tc.desc: ParamType is SOFTBUS_EVT_PARAMTYPE_INT32
102 * @tc.type: FUNC
103 * @tc.require: 1
104 */
105 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusWriteHisEvtTest004, TestSize.Level1)
106 {
107     SoftBusEvtParam evtParam;
108     strcpy_s(evtParam.paramName, sizeof(evtParam.paramName), "testParamName");
109     evtParam.paramType = SOFTBUS_EVT_PARAMTYPE_INT32;
110     evtParam.paramValue.i32v = INT32_MAX;
111 
112     SoftBusEvtReportMsg reportMsg;
113     reportMsg.evtType = SOFTBUS_EVT_TYPE_FAULT;
114     reportMsg.paramArray = &evtParam;
115     reportMsg.paramNum = 1;
116     strcpy_s(reportMsg.evtName, sizeof(evtParam.paramName), "testEvent");
117     int32_t ret = SoftbusWriteHisEvt(&reportMsg);
118     EXPECT_EQ(SOFTBUS_OK, ret);
119 }
120 
121 /*
122 * @tc.name: SoftbusWriteHisEvtTest005
123 * @tc.desc: ParamType is SOFTBUS_EVT_PARAMTYPE_UINT32
124 * @tc.type: FUNC
125 * @tc.require: 1
126 */
127 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusWriteHisEvtTest005, TestSize.Level1)
128 {
129     SoftBusEvtParam evtParam;
130     strcpy_s(evtParam.paramName, sizeof(evtParam.paramName), "testParamName");
131     evtParam.paramType = SOFTBUS_EVT_PARAMTYPE_UINT32;
132     evtParam.paramValue.u32v = UINT32_MAX;
133 
134     SoftBusEvtReportMsg reportMsg;
135     reportMsg.evtType = SOFTBUS_EVT_TYPE_FAULT;
136     reportMsg.paramArray = &evtParam;
137     reportMsg.paramNum = 1;
138     strcpy_s(reportMsg.evtName, sizeof(evtParam.paramName), "testEvent");
139     int32_t ret = SoftbusWriteHisEvt(&reportMsg);
140     EXPECT_EQ(SOFTBUS_OK, ret);
141 }
142 
143 /*
144 * @tc.name: SoftbusWriteHisEvtTest006
145 * @tc.desc: ParamType is SOFTBUS_EVT_PARAMTYPE_UINT64
146 * @tc.type: FUNC
147 * @tc.require: 1
148 */
149 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusWriteHisEvtTest006, TestSize.Level1)
150 {
151     SoftBusEvtParam evtParam;
152     strcpy_s(evtParam.paramName, sizeof(evtParam.paramName), "testParamName");
153     evtParam.paramType = SOFTBUS_EVT_PARAMTYPE_UINT64;
154     evtParam.paramValue.u64v = UINT64_MAX;
155 
156     SoftBusEvtReportMsg reportMsg;
157     reportMsg.evtType = SOFTBUS_EVT_TYPE_FAULT;
158     reportMsg.paramArray = &evtParam;
159     reportMsg.paramNum = 1;
160     strcpy_s(reportMsg.evtName, sizeof(evtParam.paramName), "testEvent");
161     int32_t ret = SoftbusWriteHisEvt(&reportMsg);
162     EXPECT_EQ(SOFTBUS_OK, ret);
163 }
164 
165 /*
166 * @tc.name: SoftbusWriteHisEvtTest007
167 * @tc.desc: ParamType is SOFTBUS_EVT_PARAMTYPE_FLOAT
168 * @tc.type: FUNC
169 * @tc.require: 1
170 */
171 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusWriteHisEvtTest007, TestSize.Level1)
172 {
173     SoftBusEvtParam evtParam;
174     strcpy_s(evtParam.paramName, sizeof(evtParam.paramName), "testParamName");
175     evtParam.paramType = SOFTBUS_EVT_PARAMTYPE_FLOAT;
176     evtParam.paramValue.f = 0.1f;
177 
178     SoftBusEvtReportMsg reportMsg;
179     reportMsg.evtType = SOFTBUS_EVT_TYPE_FAULT;
180     reportMsg.paramArray = &evtParam;
181     reportMsg.paramNum = 1;
182     strcpy_s(reportMsg.evtName, sizeof(evtParam.paramName), "testEvent");
183     int32_t ret = SoftbusWriteHisEvt(&reportMsg);
184     EXPECT_EQ(SOFTBUS_OK, ret);
185 }
186 
187 /*
188 * @tc.name: SoftbusWriteHisEvtTest008
189 * @tc.desc: ParamType is SOFTBUS_EVT_PARAMTYPE_DOUBLE
190 * @tc.type: FUNC
191 * @tc.require: 1
192 */
193 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusWriteHisEvtTest008, TestSize.Level1)
194 {
195     SoftBusEvtParam evtParam;
196     strcpy_s(evtParam.paramName, sizeof(evtParam.paramName), "testParamName");
197     evtParam.paramType = SOFTBUS_EVT_PARAMTYPE_DOUBLE;
198     evtParam.paramValue.d = 0.2;
199 
200     SoftBusEvtReportMsg reportMsg;
201     reportMsg.evtType = SOFTBUS_EVT_TYPE_FAULT;
202     reportMsg.paramArray = &evtParam;
203     reportMsg.paramNum = 1;
204     strcpy_s(reportMsg.evtName, sizeof(evtParam.paramName), "testEvent");
205     int32_t ret = SoftbusWriteHisEvt(&reportMsg);
206     EXPECT_EQ(SOFTBUS_OK, ret);
207 }
208 
209 /*
210 * @tc.name: SoftbusWriteHisEvtTest009
211 * @tc.desc: ParamType is SOFTBUS_EVT_PARAMTYPE_STRING
212 * @tc.type: FUNC
213 * @tc.require: 1
214 */
215 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusWriteHisEvtTest009, TestSize.Level1)
216 {
217     SoftBusEvtParam evtParam;
218     strcpy_s(evtParam.paramName, sizeof(evtParam.paramName), "testParamName");
219     evtParam.paramType = SOFTBUS_EVT_PARAMTYPE_STRING;
220     strcpy_s(evtParam.paramValue.str, sizeof(evtParam.paramValue.str), "testParamValue");
221 
222     SoftBusEvtReportMsg reportMsg;
223     reportMsg.evtType = SOFTBUS_EVT_TYPE_FAULT;
224     reportMsg.paramArray = &evtParam;
225     reportMsg.paramNum = 1;
226     strcpy_s(reportMsg.evtName, sizeof(evtParam.paramName), "testevent");
227     int32_t ret = SoftbusWriteHisEvt(&reportMsg);
228     EXPECT_EQ(SOFTBUS_OK, ret);
229 }
230 
231 /*
232 * @tc.name: SoftbusWriteHisEvtTest010
233 * @tc.desc: ParamType is SOFTBUS_EVT_PARAMTYPE_BUTT
234 * @tc.type: FUNC
235 * @tc.require: 1
236 */
237 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusWriteHisEvtTest010, TestSize.Level1)
238 {
239     SoftBusEvtParam evtParam;
240     strcpy_s(evtParam.paramName, sizeof(evtParam.paramName), "testParamName");
241     evtParam.paramType = SOFTBUS_EVT_PARAMTYPE_BUTT;
242     strcpy_s(evtParam.paramValue.str, sizeof(evtParam.paramValue.str), "testParamValue");
243 
244     SoftBusEvtReportMsg reportMsg;
245     reportMsg.evtType = SOFTBUS_EVT_TYPE_FAULT;
246     reportMsg.paramArray = &evtParam;
247     reportMsg.paramNum = 1;
248     strcpy_s(reportMsg.evtName, sizeof(evtParam.paramName), "testevent");
249     int32_t ret = SoftbusWriteHisEvt(&reportMsg);
250     EXPECT_EQ(SOFTBUS_OK, ret);
251 }
252 
253 /*
254 * @tc.name: SoftbusWriteHisEvtTest021
255 * @tc.desc: evtType is SOFTBUS_EVT_TYPE_STATISTIC
256 * @tc.type: FUNC
257 * @tc.require: 1
258 */
259 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusWriteHisEvtTest021, TestSize.Level1)
260 {
261     SoftBusEvtParam evtParam;
262     strcpy_s(evtParam.paramName, sizeof(evtParam.paramName), "testParamName");
263     evtParam.paramType = SOFTBUS_EVT_PARAMTYPE_STRING;
264     strcpy_s(evtParam.paramValue.str, sizeof(evtParam.paramValue.str), "testParamValue");
265 
266     SoftBusEvtReportMsg reportMsg;
267     reportMsg.evtType = SOFTBUS_EVT_TYPE_STATISTIC;
268     reportMsg.paramArray = &evtParam;
269     reportMsg.paramNum = 1;
270     strcpy_s(reportMsg.evtName, sizeof(evtParam.paramName), "testevent");
271     int32_t ret = SoftbusWriteHisEvt(&reportMsg);
272     EXPECT_EQ(SOFTBUS_OK, ret);
273 }
274 
275 
276 /*
277 * @tc.name: SoftbusWriteHisEvtTest022
278 * @tc.desc: evtType is SOFTBUS_EVT_TYPE_SECURITY
279 * @tc.type: FUNC
280 * @tc.require: 1
281 */
282 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusWriteHisEvtTest022, TestSize.Level1)
283 {
284     SoftBusEvtParam evtParam;
285     strcpy_s(evtParam.paramName, sizeof(evtParam.paramName), "testParamName");
286     evtParam.paramType = SOFTBUS_EVT_PARAMTYPE_STRING;
287     strcpy_s(evtParam.paramValue.str, sizeof(evtParam.paramValue.str), "testParamValue");
288 
289     SoftBusEvtReportMsg reportMsg;
290     reportMsg.evtType = SOFTBUS_EVT_TYPE_SECURITY;
291     reportMsg.paramArray = &evtParam;
292     reportMsg.paramNum = 1;
293     strcpy_s(reportMsg.evtName, sizeof(evtParam.paramName), "testevent");
294     int32_t ret = SoftbusWriteHisEvt(&reportMsg);
295     EXPECT_EQ(SOFTBUS_OK, ret);
296 }
297 
298 
299 /*
300 * @tc.name: SoftbusWriteHisEvtTest023
301 * @tc.desc: evtType is SOFTBUS_EVT_TYPE_BEHAVIOR
302 * @tc.type: FUNC
303 * @tc.require: 1
304 */
305 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusWriteHisEvtTest023, TestSize.Level1)
306 {
307     SoftBusEvtParam evtParam;
308     strcpy_s(evtParam.paramName, sizeof(evtParam.paramName), "testParamName");
309     evtParam.paramType = SOFTBUS_EVT_PARAMTYPE_STRING;
310     strcpy_s(evtParam.paramValue.str, sizeof(evtParam.paramValue.str), "testParamValue");
311 
312     SoftBusEvtReportMsg reportMsg;
313     reportMsg.evtType = SOFTBUS_EVT_TYPE_BEHAVIOR;
314     reportMsg.paramArray = &evtParam;
315     reportMsg.paramNum = 1;
316     strcpy_s(reportMsg.evtName, sizeof(evtParam.paramName), "testevent");
317     int32_t ret = SoftbusWriteHisEvt(&reportMsg);
318     EXPECT_EQ(SOFTBUS_OK, ret);
319 }
320 
321 
322 /*
323 * @tc.name: SoftbusWriteHisEvtTest024
324 * @tc.desc: evtType is SOFTBUS_EVT_TYPE_BUTT
325 * @tc.type: FUNC
326 * @tc.require: 1
327 */
328 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusWriteHisEvtTest024, TestSize.Level1)
329 {
330     SoftBusEvtParam evtParam;
331     strcpy_s(evtParam.paramName, sizeof(evtParam.paramName), "testParamName");
332     evtParam.paramType = SOFTBUS_EVT_PARAMTYPE_STRING;
333     strcpy_s(evtParam.paramValue.str, sizeof(evtParam.paramValue.str), "testParamValue");
334 
335     SoftBusEvtReportMsg reportMsg;
336     reportMsg.evtType = SOFTBUS_EVT_TYPE_BUTT;
337     reportMsg.paramArray = &evtParam;
338     reportMsg.paramNum = 1;
339     strcpy_s(reportMsg.evtName, sizeof(evtParam.paramName), "testevent");
340     int32_t ret = SoftbusWriteHisEvt(&reportMsg);
341     EXPECT_EQ(SOFTBUS_OK, ret);
342 }
343 
344 /*
345 * @tc.name: SoftbusWriteHisEvtTest031
346 * @tc.desc: paramNum is -1
347 * @tc.type: FUNC
348 * @tc.require: 1
349 */
350 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusWriteHisEvtTest031, TestSize.Level1)
351 {
352     int32_t paramNum = -1;
353     SoftBusEvtReportMsg* msg = SoftbusCreateEvtReportMsg(paramNum);
354     int32_t ret = SoftbusWriteHisEvt(msg);
355     EXPECT_EQ(SOFTBUS_ERR, ret);
356     SoftbusFreeEvtReportMsg(msg);
357 }
358 
359 /*
360 * @tc.name: SoftbusCreateEvtReportMsgTest001
361 * @tc.desc: Create softbus event report message nllptr
362 * @tc.type: FUNC
363 * @tc.require: 1
364 */
365 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusCreateEvtReportMsgTest001, TestSize.Level1)
366 {
367     int32_t paramNum = -1;
368     SoftBusEvtReportMsg* msg = SoftbusCreateEvtReportMsg(paramNum);
369     EXPECT_EQ(nullptr, msg);
370     SoftbusFreeEvtReportMsg(msg);
371 }
372 
373 /*
374 * @tc.name: SoftbusCreateEvtReportMsgTest002
375 * @tc.desc: Create softbus event report message nllptr
376 * @tc.type: FUNC
377 * @tc.require: 1
378 */
379 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusCreateEvtReportMsgTest002, TestSize.Level1)
380 {
381     int32_t paramNum = SOFTBUS_EVT_PARAM_ZERO;
382     SoftBusEvtReportMsg* msg = SoftbusCreateEvtReportMsg(paramNum);
383     EXPECT_EQ(nullptr, msg);
384     SoftbusFreeEvtReportMsg(msg);
385 }
386 
387 /*
388 * @tc.name: SoftbusCreateEvtReportMsgTest003
389 * @tc.desc: Create softbus event report message nllptr
390 * @tc.type: FUNC
391 * @tc.require: 1
392 */
393 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusCreateEvtReportMsgTest003, TestSize.Level1)
394 {
395     int32_t paramNum = INT32_MAX;
396     SoftBusEvtReportMsg* msg = SoftbusCreateEvtReportMsg(paramNum);
397     EXPECT_EQ(nullptr, msg);
398     SoftbusFreeEvtReportMsg(msg);
399 }
400 
401 /*
402 * @tc.name: SoftbusCreateEvtReportMsgTest004
403 * @tc.desc: Create softbus event report message nllptr
404 * @tc.type: FUNC
405 * @tc.require: 1
406 */
407 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusCreateEvtReportMsgTest004, TestSize.Level1)
408 {
409     int32_t paramNum = SOFTBUS_EVT_PARAM_BUTT;
410     SoftBusEvtReportMsg* msg = SoftbusCreateEvtReportMsg(paramNum);
411     EXPECT_EQ(nullptr, msg);
412     // free nullptr message
413     SoftbusFreeEvtReportMsg(msg);
414 }
415 
416 /*
417 * @tc.name: SoftbusCreateEvtReportMsgTest005
418 * @tc.desc: Create softbus event report message
419 * @tc.type: FUNC
420 * @tc.require: 1
421 */
422 HWTEST_F(AdapterDsoftbusDfxTest, SoftbusCreateEvtReportMsgTest005, TestSize.Level1)
423 {
424     int32_t paramNum = SOFTBUS_EVT_PARAM_ONE;
425     SoftBusEvtReportMsg* msg = SoftbusCreateEvtReportMsg(paramNum);
426     EXPECT_NE(nullptr, msg);
427     SoftbusFreeEvtReportMsg(msg);
428 }
429 
430 }