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 <gtest/gtest.h>
17
18 #include <limits>
19 #include <memory>
20
21 #include "gtest/gtest-message.h"
22 #include "gtest/gtest-test-part.h"
23 #include "gtest/hwext/gtest-ext.h"
24 #include "gtest/hwext/gtest-tag.h"
25
26 #include "encoded_param.h"
27 #include "raw_data_base_def.h"
28 #include "raw_data_builder_json_parser.h"
29 #include "raw_data_builder.h"
30 #include "raw_data_encoder.h"
31 #include "raw_data.h"
32
33 #include "hisysevent.h"
34 #include "hitrace/trace.h"
35
36 using namespace testing::ext;
37 using namespace OHOS::HiviewDFX;
38 using namespace OHOS::HiviewDFX::Encoded;
39
40 class HiSysEventEncodedTest : public testing::Test {
41 public:
42 static void SetUpTestCase(void);
43 static void TearDownTestCase(void);
44 void SetUp();
45 void TearDown();
46 };
47
SetUpTestCase(void)48 void HiSysEventEncodedTest::SetUpTestCase(void)
49 {
50 }
51
TearDownTestCase(void)52 void HiSysEventEncodedTest::TearDownTestCase(void)
53 {
54 }
55
SetUp(void)56 void HiSysEventEncodedTest::SetUp(void)
57 {
58 }
59
TearDown(void)60 void HiSysEventEncodedTest::TearDown(void)
61 {
62 }
63
64 /**
65 * @tc.name: RawDataBuilderJsonParserTest001
66 * @tc.desc: Construct RawDataBuilderJsonParser with empty string
67 * @tc.type: FUNC
68 * @tc.require: issueI7E737
69 */
70 HWTEST_F(HiSysEventEncodedTest, RawDataBuilderJsonParserTest001, TestSize.Level1)
71 {
72 auto jsonParser = std::make_shared<RawDataBuilderJsonParser>("");
73 ASSERT_TRUE(jsonParser != nullptr);
74 auto eventBuilder = jsonParser->Parse();
75 ASSERT_TRUE(eventBuilder != nullptr);
76 }
77
78 /**
79 * @tc.name: RawDataBuilderJsonParserTest002
80 * @tc.desc: Construct RawDataBuilderJsonParser with valid string
81 * @tc.type: FUNC
82 * @tc.require: issueI7E737
83 */
84 HWTEST_F(HiSysEventEncodedTest, RawDataBuilderJsonParserTest002, TestSize.Level1)
85 {
86 std::string rawSysEventStr = R"~({"domain_":"KERNEL_VENDOR","name_":"POWER_KEY",
87 "type_":1,"time_":1502603794820,"tz_":"+0800","pid_":1751,"tid_":1751,"uid_":0,
88 "id_":"17835276947892625495","trace_flag_":3,"traceid_":"a92ab1ea12c7144",
89 "spanid_":"0","pspanid_":"0","key1":"-300","key2":[-300, 300],
90 "key3":3.4,"key4":"[3.4,-3.4]","info_":"","level_":"CRITICAL","seq_":972})~";
91 auto jsonParser = std::make_shared<RawDataBuilderJsonParser>(rawSysEventStr);
92 ASSERT_TRUE(jsonParser != nullptr);
93 auto eventBuilder = jsonParser->Parse();
94 ASSERT_TRUE(eventBuilder != nullptr && eventBuilder->GetDomain() == "KERNEL_VENDOR" &&
95 eventBuilder->GetName() == "POWER_KEY");
96 }
97
98 /**
99 * @tc.name: RawDataTest001
100 * @tc.desc: RawData constructor test
101 * @tc.type: FUNC
102 * @tc.require: issueI7E737
103 */
104 HWTEST_F(HiSysEventEncodedTest, RawDataTest001, TestSize.Level1)
105 {
106 auto dataBuilderEmpty = std::make_shared<RawDataBuilder>();
107 ASSERT_TRUE(dataBuilderEmpty != nullptr);
108 RawData originEmpty = *(dataBuilderEmpty->Build());
109 RawData dest1(originEmpty.GetData(), originEmpty.GetDataLength());
110 ASSERT_TRUE(dest1.GetData() != nullptr);
111 RawData dest2(originEmpty);
112 ASSERT_TRUE(dest2.GetData() != nullptr);
113 auto dataBuilder = std::make_shared<RawDataBuilder>();
114 ASSERT_TRUE(dataBuilder != nullptr);
115 dataBuilder->AppendDomain("DOMAIN");
116 dataBuilder->AppendName("NAME");
117 dataBuilder->AppendType(HiSysEvent::EventType::SECURITY);
118 RawData origin = *(dataBuilder->Build());
119 RawData dest3(origin.GetData(), origin.GetDataLength());
120 ASSERT_TRUE((dest3.GetDataLength() > 0) && (dest3.GetData() != nullptr));
121 RawData dest4(origin);
122 ASSERT_TRUE((dest4.GetDataLength() > 0) && (dest4.GetData() != nullptr));
123 }
124
125 /**
126 * @tc.name: RawDataTest002
127 * @tc.desc: RawData assign, reset and update api test
128 * @tc.type: FUNC
129 * @tc.require: issueI7E737
130 */
131 HWTEST_F(HiSysEventEncodedTest, RawDataTest002, TestSize.Level1)
132 {
133 auto dataBuilderEmpty = std::make_shared<RawDataBuilder>();
134 ASSERT_TRUE(dataBuilderEmpty != nullptr);
135 RawData originEmpty = *(dataBuilderEmpty->Build());
136 RawData tmpData = originEmpty;
137 originEmpty.Reset();
138 ASSERT_TRUE(originEmpty.GetDataLength() == 0);
139 auto ret = originEmpty.Update(nullptr, 0, 0);
140 ASSERT_TRUE(!ret);
141 auto dataBuilder = std::make_shared<RawDataBuilder>();
142 ASSERT_TRUE(dataBuilder != nullptr);
143 dataBuilder->AppendDomain("DOMAIN");
144 dataBuilder->AppendName("NAME");
145 RawData origin = *(dataBuilderEmpty->Build());
146 ret = originEmpty.Update(origin.GetData(), origin.GetDataLength(), 100); // 100 is an invalid position
147 ASSERT_TRUE(!ret);
148 RawData tmpData2 = origin;
149 ASSERT_TRUE(origin.GetDataLength() > 0);
150 origin.Reset();
151 ASSERT_TRUE(origin.GetDataLength() == 0);
152 ASSERT_TRUE(tmpData2.GetDataLength() > 0);
153 }
154
155 /**
156 * @tc.name: EncodeParamTest001
157 * @tc.desc: EncodeParam api interfaces test
158 * @tc.type: FUNC
159 * @tc.require: issueI7E737
160 */
161 HWTEST_F(HiSysEventEncodedTest, EncodeParamTest001, TestSize.Level1)
162 {
163 uint64_t val = 39912344; // a random numeber
164 std::shared_ptr<EncodedParam> param = std::make_shared<UnsignedVarintEncodedParam<uint64_t>>("KEY", val);
165 RawData data = param->GetRawData();
166 ASSERT_TRUE((data.GetData() != nullptr) && (data.GetDataLength() > 0));
167 uint64_t destUint64Val;
168 ASSERT_TRUE(param->AsUint64(destUint64Val));
169 ASSERT_TRUE(destUint64Val == val);
170 int64_t destInt64Val;
171 ASSERT_TRUE(!param->AsInt64(destInt64Val));
172 std::string destStrVal;
173 ASSERT_TRUE(param->AsString(destStrVal));
174 ASSERT_TRUE(destStrVal == std::to_string(val));
175 double destDoubleVal;
176 ASSERT_TRUE(!param->AsDouble(destDoubleVal));
177 std::vector<uint64_t> destUintArrayVal;
178 ASSERT_TRUE(!param->AsUint64Vec(destUintArrayVal));
179 std::vector<int64_t> destIntArrayVal;
180 ASSERT_TRUE(!param->AsInt64Vec(destIntArrayVal));
181 std::vector<double> destDoubleArrayVal;
182 ASSERT_TRUE(!param->AsDoubleVec(destDoubleArrayVal));
183 std::vector<std::string> destStrArrayVal;
184 ASSERT_TRUE(!param->AsStringVec(destStrArrayVal));
185 }
186
187 /**
188 * @tc.name: RawDataBuilderTest001
189 * @tc.desc: RawDataBuilder api interfaces test
190 * @tc.type: FUNC
191 * @tc.require: issueI7E737
192 */
193 HWTEST_F(HiSysEventEncodedTest, RawDataBuilderTest001, TestSize.Level1)
194 {
195 auto dataBuilder = std::make_shared<RawDataBuilder>();
196 ASSERT_TRUE(dataBuilder != nullptr);
197 dataBuilder->AppendDomain("DOMAIN");
198 dataBuilder->AppendName("NAME");
199 dataBuilder->AppendType(HiSysEvent::EventType::SECURITY);
200 dataBuilder->AppendTimeStamp(1502603794820); // a random timestamp
201 dataBuilder->AppendTimeZone(3); // 3 is a valid index
202 dataBuilder->AppendUid(100); // 100 is a random uid
203 dataBuilder->AppendPid(1000); // 1000 is a random pid
204 dataBuilder->AppendTid(384); // 384 is a random tid
205 uint64_t id = std::numeric_limits<uint64_t>::max();
206 dataBuilder->AppendId(id);
207 dataBuilder->AppendId(std::to_string(id));
208 uint64_t traceId = std::numeric_limits<uint64_t>::max();
209 dataBuilder->AppendTraceId(traceId);
210 dataBuilder->AppendSpanId(0); // default span id is 0
211 dataBuilder->AppendPSpanId(0); // default parent span id is 0
212 dataBuilder->AppendTraceFlag(HITRACE_FLAG_INCLUDE_ASYNC | HITRACE_FLAG_DONOT_CREATE_SPAN);
213 dataBuilder->AppendValue(nullptr);
214 uint64_t val = 39912344; // a random numeber
215 std::shared_ptr<EncodedParam> param = std::make_shared<UnsignedVarintEncodedParam<uint64_t>>("KEY", val);
216 dataBuilder->AppendValue(param);
217 dataBuilder->Build();
218 std::shared_ptr<EncodedParam> param1 = dataBuilder->GetValue("KEY1");
219 ASSERT_TRUE(param1 == nullptr);
220 std::shared_ptr<EncodedParam> param2 = dataBuilder->GetValue("KEY");
221 uint64_t val2 = 0;
222 ASSERT_TRUE(param2->AsUint64(val2));
223 ASSERT_TRUE(val == val2);
224 ASSERT_TRUE(dataBuilder->GetEventType() == HiSysEvent::EventType::SECURITY);
225 auto header = dataBuilder->GetHeader();
226 ASSERT_TRUE((header.type + 1) == HiSysEvent::EventType::SECURITY);
227 auto traceInfo = dataBuilder->GetTraceInfo();
228 ASSERT_TRUE(traceInfo.traceFlag == (HITRACE_FLAG_INCLUDE_ASYNC | HITRACE_FLAG_DONOT_CREATE_SPAN));
229 }
230
231 /**
232 * @tc.name: RawDatabaseDefTest001
233 * @tc.desc: Some api interfaces of raw data base definition test
234 * @tc.type: FUNC
235 * @tc.require: issueI7E737
236 */
237 HWTEST_F(HiSysEventEncodedTest, RawDatabaseDefTest001, TestSize.Level1)
238 {
239 auto timeZone = ParseTimeZone(40); // 40 is a invalid index
240 ASSERT_TRUE(timeZone == "+0000");
241 timeZone = ParseTimeZone(15); // 15 is a valid index
242 ASSERT_TRUE(timeZone == "+0100");
243 }
244