1 /*
2  * Copyright (c) 2023 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 "event_raw_encoded_and_decoded_test.h"
17 
18 #include <memory>
19 #include <vector>
20 
21 #include "decoded/decoded_event.h"
22 #include "decoded/decoded_param.h"
23 #include "decoded/raw_data_decoder.h"
24 #include "encoded/encoded_param.h"
25 #include "encoded/raw_data_builder_json_parser.h"
26 #include "encoded/raw_data_builder.h"
27 #include "encoded/raw_data_encoder.h"
28 
29 namespace OHOS {
30 namespace HiviewDFX {
31 using namespace EventRaw;
32 namespace {
33 const std::string TEST_KEY = "KEY";
34 constexpr size_t MAX_LEN = 1000;
35 constexpr uint8_t CNT = 3;
36 }
37 
SetUpTestCase()38 void EventRawEncodedTest::SetUpTestCase()
39 {
40 }
41 
TearDownTestCase()42 void EventRawEncodedTest::TearDownTestCase()
43 {
44 }
45 
SetUp()46 void EventRawEncodedTest::SetUp()
47 {
48     platform.GetPluginMap();
49 }
50 
TearDown()51 void EventRawEncodedTest::TearDown()
52 {
53 }
54 
55 /**
56  * @tc.name: EncodedParamTest001
57  * @tc.desc: Test api interfaces of UnsignedVarintEncodedParam class
58  * @tc.type: FUNC
59  * @tc.require: issueI7X274
60  */
61 HWTEST_F(EventRawEncodedTest, EncodedParamTest001, testing::ext::TestSize.Level1)
62 {
63     uint64_t val = 100; // test value
64     auto encodedParam = std::make_shared<UnsignedVarintEncodedParam<uint64_t>>(TEST_KEY, val);
65     ASSERT_TRUE(encodedParam != nullptr);
66     std::shared_ptr<EncodedParam> param = encodedParam;
67     ASSERT_EQ(param->GetKey(), TEST_KEY);
68     ASSERT_TRUE(param->Encode());
69     ASSERT_TRUE(!param->GetRawData().IsEmpty());
70     uint64_t dest1 = 0;
71     ASSERT_TRUE(param->AsUint64(dest1));
72     ASSERT_EQ(dest1, val);
73     int64_t dest2 = 0; // test value
74     ASSERT_TRUE(!param->AsInt64(dest2));
75     double dest3 = 0.0; // test value
76     ASSERT_TRUE(!param->AsDouble(dest3));
77     std::string dest4; // test value
78     ASSERT_TRUE(param->AsString(dest4));
79     ASSERT_EQ(dest4, std::to_string(val)); // test value
80     std::vector<uint64_t> dest5;
81     ASSERT_TRUE(!param->AsUint64Vec(dest5));
82     std::vector<int64_t> dest6;
83     ASSERT_TRUE(!param->AsInt64Vec(dest6));
84     std::vector<double> dest7;
85     ASSERT_TRUE(!param->AsDoubleVec(dest7));
86     std::vector<std::string> dest8;
87     ASSERT_TRUE(!param->AsStringVec(dest8));
88 }
89 
90 /**
91  * @tc.name: EncodedParamTest002
92  * @tc.desc: Test api interfaces of UnsignedVarintEncodedArrayParam class
93  * @tc.type: FUNC
94  * @tc.require: issueI7X274
95  */
96 HWTEST_F(EventRawEncodedTest, EncodedParamTest002, testing::ext::TestSize.Level1)
97 {
98     std::vector<uint64_t> vals = {1, 200, 3000}; // test value
99     auto encodedParam = std::make_shared<UnsignedVarintEncodedArrayParam<uint64_t>>(TEST_KEY, vals);
100     ASSERT_TRUE(encodedParam != nullptr);
101     std::shared_ptr<EncodedParam> param = encodedParam;
102     ASSERT_EQ(param->GetKey(), TEST_KEY);
103     ASSERT_TRUE(param->Encode());
104     ASSERT_TRUE(!param->GetRawData().IsEmpty());
105     uint64_t dest1 = 0;
106     ASSERT_TRUE(!param->AsUint64(dest1));
107     int64_t dest2 = 0; // test value
108     ASSERT_TRUE(!param->AsInt64(dest2));
109     double dest3 = 0.0; // test value
110     ASSERT_TRUE(!param->AsDouble(dest3));
111     std::string dest4;  // test value
112     ASSERT_TRUE(!param->AsString(dest4));
113     std::vector<uint64_t> dest5;
114     ASSERT_TRUE(param->AsUint64Vec(dest5));
115     ASSERT_TRUE(dest5.size() == vals.size());
116     ASSERT_EQ(dest5[0], vals[0]); // compare by index
117     ASSERT_EQ(dest5[1], vals[1]); // compare by index
118     ASSERT_EQ(dest5[2], vals[2]); // compare by index
119     std::vector<int64_t> dest6;
120     ASSERT_TRUE(!param->AsInt64Vec(dest6));
121     std::vector<double> dest7;
122     ASSERT_TRUE(!param->AsDoubleVec(dest7));
123     std::vector<std::string> dest8;
124     ASSERT_TRUE(!param->AsStringVec(dest8));
125 }
126 
127 /**
128  * @tc.name: EncodedParamTest003
129  * @tc.desc: Test api interfaces of SignedVarintEncodedParam class
130  * @tc.type: FUNC
131  * @tc.require: issueI7X274
132  */
133 HWTEST_F(EventRawEncodedTest, EncodedParamTest003, testing::ext::TestSize.Level1)
134 {
135     int64_t val = 100; // test value
136     auto encodedParam = std::make_shared<SignedVarintEncodedParam<int64_t>>(TEST_KEY, val);
137     ASSERT_TRUE(encodedParam != nullptr);
138     std::shared_ptr<EncodedParam> param = encodedParam;
139     ASSERT_EQ(param->GetKey(), TEST_KEY);
140     ASSERT_TRUE(param->Encode());
141     ASSERT_TRUE(!param->GetRawData().IsEmpty());
142     uint64_t dest1 = 0;
143     ASSERT_TRUE(!param->AsUint64(dest1));
144     int64_t dest2 = 0; // test value
145     ASSERT_TRUE(param->AsInt64(dest2));
146     ASSERT_EQ(dest2, val);
147     double dest3 = 0.0; // test value
148     ASSERT_TRUE(!param->AsDouble(dest3));
149     std::string dest4; // test value
150     ASSERT_TRUE(param->AsString(dest4));
151     ASSERT_EQ(dest4, std::to_string(val)); // test value
152     std::vector<uint64_t> dest5;
153     ASSERT_TRUE(!param->AsUint64Vec(dest5));
154     std::vector<int64_t> dest6;
155     ASSERT_TRUE(!param->AsInt64Vec(dest6));
156     std::vector<double> dest7;
157     ASSERT_TRUE(!param->AsDoubleVec(dest7));
158     std::vector<std::string> dest8;
159     ASSERT_TRUE(!param->AsStringVec(dest8));
160 }
161 
162 /**
163  * @tc.name: EncodedParamTest004
164  * @tc.desc: Test api interfaces of SignedVarintEncodedArrayParam class
165  * @tc.type: FUNC
166  * @tc.require: issueI7X274
167  */
168 HWTEST_F(EventRawEncodedTest, EncodedParamTest004, testing::ext::TestSize.Level1)
169 {
170     std::vector<int64_t> vals = {1, -200, 3000}; // test value
171     auto encodedParam = std::make_shared<SignedVarintEncodedArrayParam<int64_t>>(TEST_KEY, vals);
172     ASSERT_TRUE(encodedParam != nullptr);
173     std::shared_ptr<EncodedParam> param = encodedParam;
174     ASSERT_EQ(param->GetKey(), TEST_KEY);
175     ASSERT_TRUE(param->Encode());
176     ASSERT_TRUE(!param->GetRawData().IsEmpty());
177     uint64_t dest1 = 0;
178     ASSERT_TRUE(!param->AsUint64(dest1));
179     int64_t dest2 = 0; // test value
180     ASSERT_TRUE(!param->AsInt64(dest2));
181     double dest3 = 0.0; // test value
182     ASSERT_TRUE(!param->AsDouble(dest3));
183     std::string dest4;  // test value
184     ASSERT_TRUE(!param->AsString(dest4));
185     std::vector<uint64_t> dest5;
186     ASSERT_TRUE(!param->AsUint64Vec(dest5));
187     std::vector<int64_t> dest6;
188     ASSERT_TRUE(param->AsInt64Vec(dest6));
189     ASSERT_TRUE(dest6.size() == vals.size());
190     ASSERT_EQ(dest6[0], vals[0]); // compare by index
191     ASSERT_EQ(dest6[1], vals[1]); // compare by index
192     ASSERT_EQ(dest6[2], vals[2]); // compare by index
193     std::vector<double> dest7;
194     ASSERT_TRUE(!param->AsDoubleVec(dest7));
195     std::vector<std::string> dest8;
196     ASSERT_TRUE(!param->AsStringVec(dest8));
197 }
198 
199 /**
200  * @tc.name: EncodedParamTest005
201  * @tc.desc: Test api interfaces of FloatingNumberEncodedParam class
202  * @tc.type: FUNC
203  * @tc.require: issueI7X274
204  */
205 HWTEST_F(EventRawEncodedTest, EncodedParamTest005, testing::ext::TestSize.Level1)
206 {
207     double val = 100.0; // test value
208     auto encodedParam = std::make_shared<FloatingNumberEncodedParam<double>>(TEST_KEY, val);
209     ASSERT_TRUE(encodedParam != nullptr);
210     std::shared_ptr<EncodedParam> param = encodedParam;
211     ASSERT_EQ(param->GetKey(), TEST_KEY);
212     ASSERT_TRUE(param->Encode());
213     ASSERT_TRUE(!param->GetRawData().IsEmpty());
214     uint64_t dest1 = 0;
215     ASSERT_TRUE(!param->AsUint64(dest1));
216     int64_t dest2 = 0; // test value
217     ASSERT_TRUE(!param->AsInt64(dest2));
218     double dest3 = 0.0; // test value
219     ASSERT_TRUE(param->AsDouble(dest3));
220     ASSERT_EQ(dest3, val);
221     std::string dest4; // test value
222     ASSERT_TRUE(param->AsString(dest4));
223     ASSERT_EQ(dest4, std::to_string(val)); // test value
224     std::vector<uint64_t> dest5;
225     ASSERT_TRUE(!param->AsUint64Vec(dest5));
226     std::vector<int64_t> dest6;
227     ASSERT_TRUE(!param->AsInt64Vec(dest6));
228     std::vector<double> dest7;
229     ASSERT_TRUE(!param->AsDoubleVec(dest7));
230     std::vector<std::string> dest8;
231     ASSERT_TRUE(!param->AsStringVec(dest8));
232 }
233 
234 /**
235  * @tc.name: EncodedParamTest006
236  * @tc.desc: Test api interfaces of FloatingNumberEncodedArrayParam class
237  * @tc.type: FUNC
238  * @tc.require: issueI7X274
239  */
240 HWTEST_F(EventRawEncodedTest, EncodedParamTest006, testing::ext::TestSize.Level1)
241 {
242     std::vector<double> vals = {1.0, -200.0, 300}; // test value
243     auto encodedParam = std::make_shared<FloatingNumberEncodedArrayParam<double>>(TEST_KEY, vals);
244     ASSERT_TRUE(encodedParam != nullptr);
245     std::shared_ptr<EncodedParam> param = encodedParam;
246     ASSERT_EQ(param->GetKey(), TEST_KEY);
247     ASSERT_TRUE(param->Encode());
248     ASSERT_TRUE(!param->GetRawData().IsEmpty());
249     uint64_t dest1 = 0;
250     ASSERT_TRUE(!param->AsUint64(dest1));
251     int64_t dest2 = 0; // test value
252     ASSERT_TRUE(!param->AsInt64(dest2));
253     double dest3 = 0.0; // test value
254     ASSERT_TRUE(!param->AsDouble(dest3));
255     std::string dest4;  // test value
256     ASSERT_TRUE(!param->AsString(dest4));
257     std::vector<uint64_t> dest5;
258     ASSERT_TRUE(!param->AsUint64Vec(dest5));
259     std::vector<int64_t> dest6;
260     ASSERT_TRUE(!param->AsInt64Vec(dest6));
261     std::vector<double> dest7;
262     ASSERT_TRUE(param->AsDoubleVec(dest7));
263     ASSERT_TRUE(dest7.size() == vals.size());
264     ASSERT_EQ(dest7[0], vals[0]); // compare by index
265     ASSERT_EQ(dest7[1], vals[1]); // compare by index
266     ASSERT_EQ(dest7[2], vals[2]); // compare by index
267     std::vector<std::string> dest8;
268     ASSERT_TRUE(!param->AsStringVec(dest8));
269 }
270 
271 /**
272  * @tc.name: EncodedParamTest007
273  * @tc.desc: Test api interfaces of StringEncodedParam class
274  * @tc.type: FUNC
275  * @tc.require: issueI7X274
276  */
277 HWTEST_F(EventRawEncodedTest, EncodedParamTest007, testing::ext::TestSize.Level1)
278 {
279     std::string val = "100.9"; // test value
280     auto encodedParam = std::make_shared<StringEncodedParam>(TEST_KEY, val);
281     ASSERT_TRUE(encodedParam != nullptr);
282     std::shared_ptr<EncodedParam> param = encodedParam;
283     ASSERT_EQ(param->GetKey(), TEST_KEY);
284     ASSERT_TRUE(param->Encode());
285     ASSERT_TRUE(!param->GetRawData().IsEmpty());
286     uint64_t dest1 = 0;
287     ASSERT_TRUE(!param->AsUint64(dest1));
288     int64_t dest2 = 0; // test value
289     ASSERT_TRUE(!param->AsInt64(dest2));
290     double dest3 = 0.0; // test value
291     ASSERT_TRUE(!param->AsDouble(dest3));
292     std::string dest4; // test value
293     ASSERT_TRUE(param->AsString(dest4));
294     ASSERT_EQ(dest4, val);
295     ASSERT_EQ(dest4, val); // test value
296     std::vector<uint64_t> dest5;
297     ASSERT_TRUE(!param->AsUint64Vec(dest5));
298     std::vector<int64_t> dest6;
299     ASSERT_TRUE(!param->AsInt64Vec(dest6));
300     std::vector<double> dest7;
301     ASSERT_TRUE(!param->AsDoubleVec(dest7));
302     std::vector<std::string> dest8;
303     ASSERT_TRUE(!param->AsStringVec(dest8));
304 }
305 
306 /**
307  * @tc.name: EncodedParamTest008
308  * @tc.desc: Test api interfaces of StringEncodedArrayParam class
309  * @tc.type: FUNC
310  * @tc.require: issueI7X274
311  */
312 HWTEST_F(EventRawEncodedTest, EncodedParamTest008, testing::ext::TestSize.Level1)
313 {
314     std::vector<std::string> vals = {"1.0", "-200.0", "300"}; // test value
315     auto encodedParam = std::make_shared<StringEncodedArrayParam>(TEST_KEY, vals);
316     ASSERT_TRUE(encodedParam != nullptr);
317     std::shared_ptr<EncodedParam> param = encodedParam;
318     ASSERT_EQ(param->GetKey(), TEST_KEY);
319     ASSERT_TRUE(param->Encode());
320     ASSERT_TRUE(!param->GetRawData().IsEmpty());
321     uint64_t dest1 = 0;
322     ASSERT_TRUE(!param->AsUint64(dest1));
323     int64_t dest2 = 0; // test value
324     ASSERT_TRUE(!param->AsInt64(dest2));
325     double dest3 = 0.0; // test value
326     ASSERT_TRUE(!param->AsDouble(dest3));
327     std::string dest4;  // test value
328     ASSERT_TRUE(!param->AsString(dest4));
329     std::vector<uint64_t> dest5;
330     ASSERT_TRUE(!param->AsUint64Vec(dest5));
331     std::vector<int64_t> dest6;
332     ASSERT_TRUE(!param->AsInt64Vec(dest6));
333     std::vector<double> dest7;
334     ASSERT_TRUE(!param->AsDoubleVec(dest7));
335     std::vector<std::string> dest8;
336     ASSERT_TRUE(param->AsStringVec(dest8));
337     ASSERT_TRUE(dest8.size() == vals.size());
338     ASSERT_EQ(dest8[0], vals[0]);
339     ASSERT_EQ(dest8[1], vals[1]);
340     ASSERT_EQ(dest8[2], vals[2]);
341 }
342 
343 /**
344  * @tc.name: RawDataBuilderJsonParserTest001
345  * @tc.desc: Parse sysevent which contains floating point number with scientific notation format
346  * @tc.type: FUNC
347  * @tc.require: issueI7X274
348  */
349 HWTEST_F(EventRawEncodedTest, RawDataBuilderJsonParserTest001, testing::ext::TestSize.Level1)
350 {
351     std::string rawSysEventStr = "{\"domain_\":\"DEMO\",\"name_\":\"EVENT_NAME_A\",\"type_\":4,\
352         \"PARAM_A\":3.4,\"UINT64_T\":18446744073709551610,\"DOUBLE_T\":3.34523e+05,\"INT64_T\":9223372036854775800,\
353         \"PARAM_B\":[\"123\", \"456\", \"789\"],\"PARAM_C\":[]}";
354     auto parser = std::make_shared<RawDataBuilderJsonParser>(rawSysEventStr);
355     ASSERT_TRUE(parser != nullptr);
356     auto eventBuilder = parser->Parse();
357     ASSERT_TRUE(eventBuilder != nullptr);
358     ASSERT_EQ(eventBuilder->GetDomain(), "DEMO");
359     ASSERT_EQ(eventBuilder->GetName(), "EVENT_NAME_A");
360     ASSERT_EQ(eventBuilder->GetEventType(), 4);
361     uint64_t val = 0.0;
362     eventBuilder->ParseValueByKey("INT64_T", val);
363     ASSERT_EQ(val, 9223372036854775800);
364 }
365 
366 /**
367  * @tc.name: RawDataBuilderJsonParserTest002
368  * @tc.desc: Construct RawDataBuilderJsonParser with empty string
369  * @tc.type: FUNC
370  * @tc.require: issueI7X274
371  */
372 HWTEST_F(EventRawEncodedTest, RawDataBuilderJsonParserTest002, testing::ext::TestSize.Level1)
373 {
374     auto parser = std::make_shared<RawDataBuilderJsonParser>("");
375     ASSERT_TRUE(parser != nullptr);
376     auto eventBuilder = parser->Parse();
377     ASSERT_TRUE(eventBuilder != nullptr);
378 }
379 
380 /**
381  * @tc.name: RawDataBuilderJsonParserTest003
382  * @tc.desc: Construct RawDataBuilderJsonParser with valid string
383  * @tc.type: FUNC
384  * @tc.require: issueI7X274
385  */
386 HWTEST_F(EventRawEncodedTest, RawDataBuilderJsonParserTest003, testing::ext::TestSize.Level1)
387 {
388     std::string rawSysEventStr = R"~({"domain_":"KERNEL_VENDOR", "name_":"POWER_KEY",
389         "type_":1, "time_":1502603794820, "tz_":"+0800", "pid_":1751, "tid_":1751, "uid_":0,
390         "id_":"17835276947892625495", "trace_flag_":3, "traceid_":"a92ab1ea12c7144",
391         "spanid_":"0", "pspanid_":"0", "key1":"-300", "key2":[-300, 300],
392         "key3":3.4, "key4":"[3.4,-3.4]", "info_":"", "level_":"CRITICAL", "seq_":972})~";
393     auto parser = std::make_shared<RawDataBuilderJsonParser>(rawSysEventStr);
394     ASSERT_TRUE(parser != nullptr);
395     auto eventBuilder = parser->Parse();
396     ASSERT_TRUE(eventBuilder != nullptr && eventBuilder->GetDomain() == "KERNEL_VENDOR" &&
397         eventBuilder->GetName() == "POWER_KEY");
398 }
399 
400 /**
401  * @tc.name: EncodedAndThenDecodedTest001
402  * @tc.desc: Encode uint64_t type and then decoded
403  * @tc.type: FUNC
404  * @tc.require: issueI7X274
405  */
406 HWTEST_F(EventRawEncodedTest, EncodedAndThenDecodedTest001, testing::ext::TestSize.Level1)
407 {
408     RawData data;
409     size_t decodedOffset = 0;
410     uint64_t origin = 100; // test value
411     RawDataEncoder::UnsignedVarintEncoded(data, EncodeType::VARINT, origin);
412     uint64_t dest = 0;
413     RawDataDecoder::UnsignedVarintDecoded(data.GetData(), MAX_LEN, decodedOffset, dest);
414     ASSERT_EQ(origin, dest);
415 }
416 
417 /**
418  * @tc.name: EncodedAndThenDecodedTest002
419  * @tc.desc: Encode int64_t type and then decoded
420  * @tc.type: FUNC
421  * @tc.require: issueI7X274
422  */
423 HWTEST_F(EventRawEncodedTest, EncodedAndThenDecodedTest002, testing::ext::TestSize.Level1)
424 {
425     RawData data;
426     size_t decodedOffset = 0;
427     int64_t origin = -100; // test value
428     RawDataEncoder::SignedVarintEncoded(data, EncodeType::VARINT, origin);
429     int64_t dest = 0;
430     RawDataDecoder::SignedVarintDecoded(data.GetData(), MAX_LEN, decodedOffset, dest);
431     ASSERT_EQ(origin, dest);
432 }
433 
434 /**
435  * @tc.name: EncodedAndThenDecodedTest003
436  * @tc.desc: Encode uint64_t type and then decoded
437  * @tc.type: FUNC
438  * @tc.require: issueI7X274
439  */
440 HWTEST_F(EventRawEncodedTest, EncodedAndThenDecodedTest003, testing::ext::TestSize.Level1)
441 {
442     RawData data;
443     size_t decodedOffset = 0;
444     double origin = 100.0; // test value
445     RawDataEncoder::FloatingNumberEncoded(data, origin);
446     double dest = 0.0;
447     RawDataDecoder::FloatingNumberDecoded(data.GetData(), MAX_LEN, decodedOffset, dest);
448     ASSERT_EQ(origin, dest);
449 }
450 
451 /**
452  * @tc.name: EncodedAndThenDecodedTest004
453  * @tc.desc: Encode string type and then decoded
454  * @tc.type: FUNC
455  * @tc.require: issueI7X274
456  */
457 HWTEST_F(EventRawEncodedTest, EncodedAndThenDecodedTest004, testing::ext::TestSize.Level1)
458 {
459     RawData data;
460     size_t decodedOffset = 0;
461     std::string origin = "TEST_VALUE"; // test value
462     RawDataEncoder::StringValueEncoded(data, origin);
463     std::string dest;
464     RawDataDecoder::StringValueDecoded(data.GetData(), MAX_LEN, decodedOffset, dest);
465     ASSERT_EQ(origin, dest);
466 }
467 
468 /**
469  * @tc.name: EncodedAndThenDecodedTest005
470  * @tc.desc: Encode ValueType type and then decoded
471  * @tc.type: FUNC
472  * @tc.require: issueI7X274
473  */
474 HWTEST_F(EventRawEncodedTest, EncodedAndThenDecodedTest005, testing::ext::TestSize.Level1)
475 {
476     RawData data;
477     size_t decodedOffset = 0;
478     RawDataEncoder::ValueTypeEncoded(data, false, ValueType::BOOL, CNT);
479     struct ParamValueType dest;
480     RawDataDecoder::ValueTypeDecoded(data.GetData(), MAX_LEN, decodedOffset, dest);
481     ASSERT_EQ(dest.isArray, false);
482     ASSERT_EQ(dest.valueType, 1); // enum ValueType::BOOL is 1
483     ASSERT_EQ(dest.valueByteCnt, CNT); //
484 }
485 
486 /**
487  * @tc.name: DecodedParamTest001
488  * @tc.desc: Test api interfaces of UnsignedVarintDecodedParam class
489  * @tc.type: FUNC
490  * @tc.require: issueI7X274
491  */
492 HWTEST_F(EventRawEncodedTest, DecodedParamTest001, testing::ext::TestSize.Level1)
493 {
494     RawData data;
495     size_t decodedOffset = 0;
496     uint64_t val = 100; // test value
497     RawDataEncoder::UnsignedVarintEncoded(data, EncodeType::VARINT, val);
498     auto decodedParam = std::make_shared<UnsignedVarintDecodedParam>(data.GetData(), MAX_LEN, decodedOffset,
499         TEST_KEY);
500     ASSERT_TRUE(decodedParam != nullptr);
501     std::shared_ptr<DecodedParam> param = decodedParam;
502     ASSERT_EQ(param->GetKey(), TEST_KEY);
503     ASSERT_TRUE(param->DecodeValue());
504     uint64_t dest1 = 0;
505     ASSERT_TRUE(param->AsUint64(dest1));
506     ASSERT_EQ(dest1, val);
507     int64_t dest2 = 0; // test value
508     ASSERT_TRUE(!param->AsInt64(dest2));
509     double dest3 = 0.0; // test value
510     ASSERT_TRUE(!param->AsDouble(dest3));
511     std::string dest4; // test value
512     ASSERT_TRUE(!param->AsString(dest4));
513     std::vector<uint64_t> dest5;
514     ASSERT_TRUE(!param->AsUint64Vec(dest5));
515     std::vector<int64_t> dest6;
516     ASSERT_TRUE(!param->AsInt64Vec(dest6));
517     std::vector<double> dest7;
518     ASSERT_TRUE(!param->AsDoubleVec(dest7));
519     std::vector<std::string> dest8;
520     ASSERT_TRUE(!param->AsStringVec(dest8));
521 }
522 
523 /**
524  * @tc.name: DecodedParamTest002
525  * @tc.desc: Test api interfaces of UnsignedVarintDecodedArrayParam class
526  * @tc.type: FUNC
527  * @tc.require: issueI7X274
528  */
529 HWTEST_F(EventRawEncodedTest, DecodedParamTest002, testing::ext::TestSize.Level1)
530 {
531     RawData data;
532     size_t decodedOffset = 0;
533     std::vector<uint64_t> vals = {1, 2, 3}; // test value
534     RawDataEncoder::UnsignedVarintEncoded(data, EncodeType::LENGTH_DELIMITED, vals.size());
535     for (auto item : vals) {
536         RawDataEncoder::UnsignedVarintEncoded(data, EncodeType::VARINT, item);
537     }
538     auto decodedParam = std::make_shared<UnsignedVarintDecodedArrayParam>(data.GetData(), MAX_LEN, decodedOffset,
539         TEST_KEY);
540     ASSERT_TRUE(decodedParam != nullptr);
541     std::shared_ptr<DecodedParam> param = decodedParam;
542     ASSERT_EQ(param->GetKey(), TEST_KEY);
543     ASSERT_TRUE(param->DecodeValue());
544     uint64_t dest1 = 0;
545     ASSERT_TRUE(!param->AsUint64(dest1));
546     int64_t dest2 = 0; // test value
547     ASSERT_TRUE(!param->AsInt64(dest2));
548     double dest3 = 0.0; // test value
549     ASSERT_TRUE(!param->AsDouble(dest3));
550     std::string dest4; // test value
551     ASSERT_TRUE(!param->AsString(dest4));
552     std::vector<uint64_t> dest5;
553     ASSERT_TRUE(param->AsUint64Vec(dest5));
554     ASSERT_TRUE(dest5.size() == vals.size());
555     ASSERT_EQ(dest5[0], vals[0]);
556     ASSERT_EQ(dest5[1], vals[1]);
557     ASSERT_EQ(dest5[2], vals[2]);
558     std::vector<int64_t> dest6;
559     ASSERT_TRUE(!param->AsInt64Vec(dest6));
560     std::vector<double> dest7;
561     ASSERT_TRUE(!param->AsDoubleVec(dest7));
562     std::vector<std::string> dest8;
563     ASSERT_TRUE(!param->AsStringVec(dest8));
564 }
565 
566 /**
567  * @tc.name: DecodedParamTest003
568  * @tc.desc: Test api interfaces of SignedVarintDecodedParam class
569  * @tc.type: FUNC
570  * @tc.require: issueI7X274
571  */
572 HWTEST_F(EventRawEncodedTest, DecodedParamTest003, testing::ext::TestSize.Level1)
573 {
574     RawData data;
575     size_t decodedOffset = 0;
576     int64_t val = -100; // test value
577     RawDataEncoder::SignedVarintEncoded(data, EncodeType::VARINT, val);
578     auto decodedParam = std::make_shared<SignedVarintDecodedParam>(data.GetData(), MAX_LEN, decodedOffset,
579         TEST_KEY);
580     ASSERT_TRUE(decodedParam != nullptr);
581     std::shared_ptr<DecodedParam> param = decodedParam;
582     ASSERT_EQ(param->GetKey(), TEST_KEY);
583     ASSERT_TRUE(param->DecodeValue());
584     uint64_t dest1 = 0;
585     ASSERT_TRUE(!param->AsUint64(dest1));
586     int64_t dest2 = 0; // test value
587     ASSERT_TRUE(param->AsInt64(dest2));
588     ASSERT_EQ(dest2, val);
589     double dest3 = 0.0; // test value
590     ASSERT_TRUE(!param->AsDouble(dest3));
591     std::string dest4; // test value
592     ASSERT_TRUE(!param->AsString(dest4));
593     std::vector<uint64_t> dest5;
594     ASSERT_TRUE(!param->AsUint64Vec(dest5));
595     std::vector<int64_t> dest6;
596     ASSERT_TRUE(!param->AsInt64Vec(dest6));
597     std::vector<double> dest7;
598     ASSERT_TRUE(!param->AsDoubleVec(dest7));
599     std::vector<std::string> dest8;
600     ASSERT_TRUE(!param->AsStringVec(dest8));
601 }
602 
603 /**
604  * @tc.name: DecodedParamTest004
605  * @tc.desc: Test api interfaces of SignedVarintDecodedArrayParam class
606  * @tc.type: FUNC
607  * @tc.require: issueI7X274
608  */
609 HWTEST_F(EventRawEncodedTest, DecodedParamTest004, testing::ext::TestSize.Level1)
610 {
611     RawData data;
612     size_t decodedOffset = 0;
613     std::vector<int64_t> vals = {1, -2, 3}; // test value
614     RawDataEncoder::UnsignedVarintEncoded(data, EncodeType::LENGTH_DELIMITED, vals.size());
615     for (auto item : vals) {
616         RawDataEncoder::SignedVarintEncoded(data, EncodeType::VARINT, item);
617     }
618     auto decodedParam = std::make_shared<SignedVarintDecodedArrayParam>(data.GetData(), MAX_LEN, decodedOffset,
619         TEST_KEY);
620     ASSERT_TRUE(decodedParam != nullptr);
621     std::shared_ptr<DecodedParam> param = decodedParam;
622     ASSERT_EQ(param->GetKey(), TEST_KEY);
623     ASSERT_TRUE(param->DecodeValue());
624     uint64_t dest1 = 0;
625     ASSERT_TRUE(!param->AsUint64(dest1));
626     int64_t dest2 = 0; // test value
627     ASSERT_TRUE(!param->AsInt64(dest2));
628     double dest3 = 0.0; // test value
629     ASSERT_TRUE(!param->AsDouble(dest3));
630     std::string dest4; // test value
631     ASSERT_TRUE(!param->AsString(dest4));
632     std::vector<uint64_t> dest5;
633     ASSERT_TRUE(!param->AsUint64Vec(dest5));
634     std::vector<int64_t> dest6;
635     ASSERT_TRUE(param->AsInt64Vec(dest6));
636     ASSERT_TRUE(dest6.size() == vals.size());
637     ASSERT_EQ(dest6[0], vals[0]);
638     ASSERT_EQ(dest6[1], vals[1]);
639     ASSERT_EQ(dest6[2], vals[2]);
640     std::vector<double> dest7;
641     ASSERT_TRUE(!param->AsDoubleVec(dest7));
642     std::vector<std::string> dest8;
643     ASSERT_TRUE(!param->AsStringVec(dest8));
644 }
645 
646 /**
647  * @tc.name: DecodedParamTest005
648  * @tc.desc: Test api interfaces of FloatingNumberDecodedParam class
649  * @tc.type: FUNC
650  * @tc.require: issueI7X274
651  */
652 HWTEST_F(EventRawEncodedTest, DecodedParamTest005, testing::ext::TestSize.Level1)
653 {
654     RawData data;
655     size_t decodedOffset = 0;
656     double val = -100; // test value
657     RawDataEncoder::FloatingNumberEncoded(data, val);
658     auto decodedParam = std::make_shared<FloatingNumberDecodedParam>(data.GetData(), MAX_LEN, decodedOffset,
659         TEST_KEY);
660     ASSERT_TRUE(decodedParam != nullptr);
661     std::shared_ptr<DecodedParam> param = decodedParam;
662     ASSERT_EQ(param->GetKey(), TEST_KEY);
663     ASSERT_TRUE(param->DecodeValue());
664     uint64_t dest1 = 0;
665     ASSERT_TRUE(!param->AsUint64(dest1));
666     int64_t dest2 = 0; // test value
667     ASSERT_TRUE(!param->AsInt64(dest2));
668     double dest3 = 0.0; // test value
669     ASSERT_TRUE(param->AsDouble(dest3));
670     ASSERT_EQ(dest3, val);
671     std::string dest4; // test value
672     ASSERT_TRUE(!param->AsString(dest4));
673     std::vector<uint64_t> dest5;
674     ASSERT_TRUE(!param->AsUint64Vec(dest5));
675     std::vector<int64_t> dest6;
676     ASSERT_TRUE(!param->AsInt64Vec(dest6));
677     std::vector<double> dest7;
678     ASSERT_TRUE(!param->AsDoubleVec(dest7));
679     std::vector<std::string> dest8;
680     ASSERT_TRUE(!param->AsStringVec(dest8));
681 }
682 
683 /**
684  * @tc.name: DecodedParamTest006
685  * @tc.desc: Test api interfaces of FloatingNumberDecodedArrayParam class
686  * @tc.type: FUNC
687  * @tc.require: issueI7X274
688  */
689 HWTEST_F(EventRawEncodedTest, DecodedParamTest006, testing::ext::TestSize.Level1)
690 {
691     RawData data;
692     size_t decodedOffset = 0;
693     std::vector<double> vals = {1.2, -2.78, 3.5}; // test value
694     RawDataEncoder::UnsignedVarintEncoded(data, EncodeType::LENGTH_DELIMITED, vals.size());
695     for (auto item : vals) {
696         RawDataEncoder::FloatingNumberEncoded(data, item);
697     }
698     auto decodedParam = std::make_shared<FloatingNumberDecodedArrayParam>(data.GetData(), MAX_LEN, decodedOffset,
699         TEST_KEY);
700     ASSERT_TRUE(decodedParam != nullptr);
701     std::shared_ptr<DecodedParam> param = decodedParam;
702     ASSERT_EQ(param->GetKey(), TEST_KEY);
703     ASSERT_TRUE(param->DecodeValue());
704     uint64_t dest1 = 0;
705     ASSERT_TRUE(!param->AsUint64(dest1));
706     int64_t dest2 = 0; // test value
707     ASSERT_TRUE(!param->AsInt64(dest2));
708     double dest3 = 0.0; // test value
709     ASSERT_TRUE(!param->AsDouble(dest3));
710     std::string dest4; // test value
711     ASSERT_TRUE(!param->AsString(dest4));
712     std::vector<uint64_t> dest5;
713     ASSERT_TRUE(!param->AsUint64Vec(dest5));
714     std::vector<int64_t> dest6;
715     ASSERT_TRUE(!param->AsInt64Vec(dest6));
716     std::vector<double> dest7;
717     ASSERT_TRUE(param->AsDoubleVec(dest7));
718     ASSERT_TRUE(dest7.size() == vals.size());
719     ASSERT_EQ(dest7[0], vals[0]);
720     ASSERT_EQ(dest7[1], vals[1]);
721     ASSERT_EQ(dest7[2], vals[2]);
722     std::vector<std::string> dest8;
723     ASSERT_TRUE(!param->AsStringVec(dest8));
724 }
725 
726 /**
727  * @tc.name: DecodedParamTest007
728  * @tc.desc: Test api interfaces of StringDecodedParam class
729  * @tc.type: FUNC
730  * @tc.require: issueI7X274
731  */
732 HWTEST_F(EventRawEncodedTest, DecodedParamTest007, testing::ext::TestSize.Level1)
733 {
734     RawData data;
735     size_t decodedOffset = 0;
736     std::string val = "TEST_VALUE"; // test value
737     RawDataEncoder::StringValueEncoded(data, val);
738     auto decodedParam = std::make_shared<StringDecodedParam>(data.GetData(), MAX_LEN, decodedOffset, TEST_KEY);
739     ASSERT_TRUE(decodedParam != nullptr);
740     std::shared_ptr<DecodedParam> param = decodedParam;
741     ASSERT_EQ(param->GetKey(), TEST_KEY);
742     ASSERT_TRUE(param->DecodeValue());
743     uint64_t dest1 = 0;
744     ASSERT_TRUE(!param->AsUint64(dest1));
745     int64_t dest2 = 0; // test value
746     ASSERT_TRUE(!param->AsInt64(dest2));
747     double dest3 = 0.0; // test value
748     ASSERT_TRUE(!param->AsDouble(dest3));
749     std::string dest4; // test value
750     ASSERT_TRUE(param->AsString(dest4));
751     ASSERT_EQ(dest4, val);
752     std::vector<uint64_t> dest5;
753     ASSERT_TRUE(!param->AsUint64Vec(dest5));
754     std::vector<int64_t> dest6;
755     ASSERT_TRUE(!param->AsInt64Vec(dest6));
756     std::vector<double> dest7;
757     ASSERT_TRUE(!param->AsDoubleVec(dest7));
758     std::vector<std::string> dest8;
759     ASSERT_TRUE(!param->AsStringVec(dest8));
760 }
761 
762 /**
763  * @tc.name: DecodedParamTest008
764  * @tc.desc: Test api interfaces of StringDecodedArrayParam class
765  * @tc.type: FUNC
766  * @tc.require: issueI7X274
767  */
768 HWTEST_F(EventRawEncodedTest, DecodedParamTest008, testing::ext::TestSize.Level1)
769 {
770         RawData data;
771     size_t decodedOffset = 0;
772     std::vector<std::string> vals = {"1.2", "-2.78", "3.5"}; // test value
773     RawDataEncoder::UnsignedVarintEncoded(data, EncodeType::LENGTH_DELIMITED, vals.size());
774     for (auto item : vals) {
775         RawDataEncoder::StringValueEncoded(data, item);
776     }
777     auto decodedParam = std::make_shared<StringDecodedArrayParam>(data.GetData(), MAX_LEN, decodedOffset, TEST_KEY);
778     ASSERT_TRUE(decodedParam != nullptr);
779     std::shared_ptr<DecodedParam> param = decodedParam;
780     ASSERT_EQ(param->GetKey(), TEST_KEY);
781     ASSERT_TRUE(param->DecodeValue());
782     uint64_t dest1 = 0;
783     ASSERT_TRUE(!param->AsUint64(dest1));
784     int64_t dest2 = 0; // test value
785     ASSERT_TRUE(!param->AsInt64(dest2));
786     double dest3 = 0.0; // test value
787     ASSERT_TRUE(!param->AsDouble(dest3));
788     std::string dest4; // test value
789     ASSERT_TRUE(!param->AsString(dest4));
790     std::vector<uint64_t> dest5;
791     ASSERT_TRUE(!param->AsUint64Vec(dest5));
792     std::vector<int64_t> dest6;
793     ASSERT_TRUE(!param->AsInt64Vec(dest6));
794     std::vector<double> dest7;
795     ASSERT_TRUE(!param->AsDoubleVec(dest7));
796     std::vector<std::string> dest8;
797     ASSERT_TRUE(param->AsStringVec(dest8));
798     ASSERT_TRUE(dest8.size() == vals.size());
799     ASSERT_EQ(dest8[0], vals[0]);
800     ASSERT_EQ(dest8[1], vals[1]);
801     ASSERT_EQ(dest8[2], vals[2]);
802 }
803 
804 /**
805  * @tc.name: DecodedEventTest001
806  * @tc.desc: Test api interfaces of DecodedEvent class
807  * @tc.type: FUNC
808  * @tc.require: issueI7X274
809  */
810 HWTEST_F(EventRawEncodedTest, DecodedEventTest001, testing::ext::TestSize.Level1)
811 {
812     DecodedEvent event1(nullptr);
813     ASSERT_TRUE(!event1.IsValid());
814 
815     std::string rawSysEventStr = R"~({"domain_":"DEMO","name_":"EVENT_NAME_A","type_":4,
816         "PARAM_A":3.4,"UINT64_T":18446744073709551610,"DOUBLE_T":3.34523e+05,"INT64_T":9223372036854775800,
817         "PARAM_B":["123","456","789"],"PARAM_C":[]})~";
818     auto parser = std::make_shared<RawDataBuilderJsonParser>(rawSysEventStr);
819     ASSERT_TRUE(parser != nullptr);
820     auto builder = parser->Parse();
821     ASSERT_TRUE(builder != nullptr);
822     auto rawData = builder->Build();
823     ASSERT_TRUE(rawData != nullptr);
824     DecodedEvent event2(rawData->GetData());
825     ASSERT_TRUE(event2.IsValid());
826 }
827 
828 /**
829  * @tc.name: DecodedEventTest002
830  * @tc.desc: Test api interfaces of DecodedEvent class
831  * @tc.type: FUNC
832  * @tc.require: issueI7X274
833  */
834 HWTEST_F(EventRawEncodedTest, DecodedEventTest002, testing::ext::TestSize.Level1)
835 {
836     std::string rawSysEventStr = R"~({"domain_":"DEMO","name_":"EVENT_NAME_A","type_":4,)~";
837     rawSysEventStr.append(R"~("PARAM_A":3.4,"UINT64_T":18446744073709551610,)~");
838     rawSysEventStr.append(R"~("INT64_T":9223372036854775800,"PARAM_B":["123","456","789"],"PARAM_C":[]})~");
839     auto parser = std::make_shared<RawDataBuilderJsonParser>(rawSysEventStr);
840     ASSERT_TRUE(parser != nullptr);
841     auto builder = parser->Parse();
842     ASSERT_TRUE(builder != nullptr);
843     auto rawData = builder->Build();
844     ASSERT_TRUE(rawData != nullptr);
845     DecodedEvent event(rawData->GetData());
846     ASSERT_TRUE(event.IsValid());
847     ASSERT_TRUE(event.GetRawData() != nullptr);
848     std::string formattedStr = R"~({"domain_":"DEMO","name_":"EVENT_NAME_A","type_":4,)~";
849     formattedStr.append(
850         R"~("time_":0,"tz_":"-0100","pid_":0,"tid_":0,"uid_":0,"log_":0,"id_":"00000000000000000000",)~");
851     formattedStr.append(R"~("PARAM_A":3.4,"UINT64_T":18446744073709551610,)~");
852     formattedStr.append(R"~("INT64_T":9223372036854775800,"PARAM_B":["123","456","789"],"PARAM_C":[]})~");
853     ASSERT_EQ(event.AsJsonStr(), formattedStr);
854     auto header = event.GetHeader();
855     ASSERT_EQ(static_cast<int>(header.type), 3); // test value
856     auto traceInfo = event.GetTraceInfo();
857     ASSERT_EQ(traceInfo.traceFlag, 0); // test value
858     ASSERT_EQ(event.GetAllCustomizedValues().size(), 5); // test value
859 }
860 
861 /**
862  * @tc.name: RawDataBuilderTest001
863  * @tc.desc: Test constructors of RawDataBuilder class
864  * @tc.type: FUNC
865  * @tc.require: issueI7X274
866  */
867 HWTEST_F(EventRawEncodedTest, RawDataBuilderTest001, testing::ext::TestSize.Level1)
868 {
869     auto builder1 = std::make_shared<RawDataBuilder>();
870     ASSERT_EQ(builder1->GetDomain(), "");
871 
872     std::string rawSysEventStr = R"~({"domain_":"DEMO","name_":"EVENT_NAME_A","type_":4,
873         "PARAM_A":3.4,"UINT64_T":18446744073709551610,"DOUBLE_T":3.34523e+05,"INT64_T":9223372036854775800,
874         "PARAM_B":["123","456","789"],"PARAM_C":[]})~";
875     auto parser = std::make_shared<RawDataBuilderJsonParser>(rawSysEventStr);
876     ASSERT_TRUE(parser != nullptr);
877     auto builder2 = parser->Parse();
878     RawDataBuilder builder3(builder2->Build());
879     ASSERT_EQ(builder3.GetDomain(), builder2->GetDomain());
880 
881     RawDataBuilder builder4("DEMO", "EVENT_NAME", 4); // test value
882     ASSERT_EQ(builder4.GetDomain(), builder2->GetDomain());
883 }
884 
885 /**
886  * @tc.name: RawDataBuilderTest002
887  * @tc.desc: Test api interfaces of RawDataBuilder class
888  * @tc.type: FUNC
889  * @tc.require: issueI7X274
890  */
891 HWTEST_F(EventRawEncodedTest, RawDataBuilderTest002, testing::ext::TestSize.Level1)
892 {
893     std::string rawSysEventStr = R"~({"domain_":"DEMO","name_":"EVENT_NAME_A","type_":4,
894         "PARAM_A":3.4,"UINT64_T":18446744073709551610,"DOUBLE_T":3.34523e+05,"INT64_T":9223372036854775800,
895         "PARAM_B":["123","456","789"],"PARAM_C":[]})~";
896     auto parser = std::make_shared<RawDataBuilderJsonParser>(rawSysEventStr);
897     ASSERT_TRUE(parser != nullptr);
898     auto builder = parser->Parse();
899     ASSERT_TRUE(builder != nullptr);
900     ASSERT_TRUE(builder->Build() != nullptr);
901     auto param = builder->GetValue("DOUBLE_T");
902     ASSERT_TRUE(param != nullptr);
903     auto header = builder->GetHeader();
904     ASSERT_EQ(static_cast<int>(header.type), 3); // test value
905     auto traceInfo = builder->GetTraceInfo();
906     ASSERT_EQ(traceInfo.traceFlag, 0); // test value
907     ASSERT_EQ(builder->GetDomain(), "DEMO"); // test value
908     ASSERT_EQ(builder->GetName(), "EVENT_NAME_A"); // test value
909     ASSERT_EQ(builder->GetEventType(), 4); // test value
910     ASSERT_EQ(builder->GetParamCnt(), 6); // test value
911     ASSERT_TRUE(builder->IsBaseInfo("domain_")); // test value
912     ASSERT_TRUE(!builder->IsBaseInfo("TEST_KEY")); // test value
913 }
914 } // namespace HiviewDFX
915 } // namespace OHOS