1 /*
2 * Copyright (c) 2021 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 "tlv_ut.h"
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19
20 using namespace testing::ext;
21 using namespace testing;
22
23 namespace Hdc {
24 namespace Base {
PrintLogEx(const char * func,int line,uint8_t level,const char * msg,...)25 void PrintLogEx(const char *func, int line, uint8_t level, const char *msg, ...)
26 {
27 char buf[4096] = { 0 }; // only 4k to avoid stack overflow in 32bit or L0
28 va_list args;
29 va_start(args, msg);
30 const int size = vsnprintf_s(buf, sizeof(buf), sizeof(buf) - 1, msg, args);
31 va_end(args);
32 if (size < 0) {
33 printf("vsnprintf_s failed %d \n", size);
34 return;
35 }
36 printf("%s\n", buf);
37 }
38 }
39 #define MAX_BUFFER_SIZE (1 * 1024 * 1024 * 1024)
40 class HdcBaseTest : public testing::Test {
41 public:
42 static void SetUpTestCase(void);
43 static void TearDownTestCase(void);
44 void SetUp();
45 void TearDown();
46 private:
47 uint8_t *BuildTlv(const std::vector<uint32_t> tags,
48 const std::vector<uint32_t> sizes, uint8_t val, uint32_t &tlvsize) const;
49
TlvSize(uint32_t len)50 uint32_t TlvSize(uint32_t len) { return len + TLV_HEAD_SIZE; }
51 };
52
SetUpTestCase()53 void HdcBaseTest::SetUpTestCase()
54 {
55 }
56
TearDownTestCase()57 void HdcBaseTest::TearDownTestCase() {}
58
SetUp()59 void HdcBaseTest::SetUp() {}
60
TearDown()61 void HdcBaseTest::TearDown() {}
62
BuildTlv(const std::vector<uint32_t> tags,const std::vector<uint32_t> sizes,uint8_t val,uint32_t & tlvsize) const63 uint8_t *HdcBaseTest::BuildTlv(const std::vector<uint32_t> tags,
64 const std::vector<uint32_t> sizes,
65 uint8_t val,
66 uint32_t &tlvsize) const
67 {
68 if (tags.size() != sizes.size() || tags.empty()) {
69 WRITE_LOG(LOG_WARN, "not valid size: %u, %u", tags.size(), sizes.size());
70 return nullptr;
71 }
72 tlvsize = 0;
73 for (auto size : sizes) {
74 tlvsize += TLV_HEAD_SIZE;
75 tlvsize += size;
76 }
77
78 if (tlvsize == 0 || tlvsize > MAX_BUFFER_SIZE) {
79 WRITE_LOG(LOG_WARN, "invalid size 0");
80 return nullptr;
81 }
82 uint8_t *tlv = new (std::nothrow) uint8_t[tlvsize];
83 if (tlv == nullptr) {
84 WRITE_LOG(LOG_WARN, "not enough memory %u", tlvsize);
85 tlvsize = 0;
86 return nullptr;
87 }
88 uint32_t pos = 0;
89 int i = 0;
90 for (; pos < tlvsize && i < tags.size(); i++) {
91 *(uint32_t *)(tlv + pos) = tags[i];
92 *(uint32_t *)(tlv + pos + sizeof(tags[i])) = sizes[i];
93
94 pos += TLV_HEAD_SIZE;
95 if (memset_s(tlv + pos, tlvsize - pos, val, sizes[i]) != 0) {
96 tlvsize = 0;
97 delete[] tlv;
98 return nullptr;
99 }
100 pos += sizes[i];
101 }
102
103 return tlv;
104 }
105
106 HWTEST_F(HdcBaseTest, TlvBuf_Constructor_001, TestSize.Level0)
107 {
108 TlvBuf tb;
109 ASSERT_EQ(tb.GetBufSize(), 0);
110 }
111
112 HWTEST_F(HdcBaseTest, TlvBuf_Constructor_002, TestSize.Level0)
113 {
114 std::set<uint32_t> validtags = { 1, 2, 3 };
115 TlvBuf tb(validtags);
116 ASSERT_EQ(tb.GetBufSize(), 0);
117 }
118
119 HWTEST_F(HdcBaseTest, TlvBuf_Constructor_003, TestSize.Level0)
120 {
121 std::vector<uint32_t> tags = { 1 };
122 std::vector<uint32_t> sizes = { 1 };
123 uint32_t tlvsize = 0;
124 uint8_t *tlv = this->BuildTlv(tags, sizes, 0xAB, tlvsize);
125 ASSERT_NE(tlv, nullptr);
126
127 TlvBuf tb(tlv, tlvsize);
128 ASSERT_EQ(tb.GetBufSize(), tlvsize);
129
130 delete[] tlv;
131 }
132
133 HWTEST_F(HdcBaseTest, TlvBuf_Constructor_004, TestSize.Level0)
134 {
135 std::set<uint32_t> validtags = { 1, 2, 3 };
136
137 std::vector<uint32_t> tags = { 1 };
138 std::vector<uint32_t> sizes = { 1 };
139 uint32_t tlvsize = 0;
140 uint8_t *tlv = this->BuildTlv(tags, sizes, 0xAB, tlvsize);
141 ASSERT_NE(tlv, nullptr);
142
143 TlvBuf tb(tlv, tlvsize, validtags);
144 ASSERT_EQ(tb.GetBufSize(), tlvsize);
145
146 delete[] tlv;
147 }
148
149 HWTEST_F(HdcBaseTest, TlvBuf_Constructor_005, TestSize.Level0)
150 {
151 std::set<uint32_t> validtags = { 1, 2, 3 };
152
153 std::vector<uint32_t> tags = { 1 };
154 std::vector<uint32_t> sizes = { TLV_VALUE_MAX_LEN + 1 };
155 uint32_t tlvsize = 0;
156 uint8_t *tlv = this->BuildTlv(tags, sizes, 0xAB, tlvsize);
157 ASSERT_NE(tlv, nullptr);
158
159 TlvBuf tb(tlv, tlvsize, validtags);
160 ASSERT_EQ(tb.GetBufSize(), 0);
161
162 delete[] tlv;
163 }
164
165 HWTEST_F(HdcBaseTest, TlvBuf_Clear_001, TestSize.Level0)
166 {
167 std::vector<uint32_t> tags = { 1 };
168 std::vector<uint32_t> sizes = { 1 };
169 uint32_t tlvsize = 0;
170 uint8_t *tlv = this->BuildTlv(tags, sizes, 0xAB, tlvsize);
171 ASSERT_NE(tlv, nullptr);
172
173 TlvBuf tb(tlv, tlvsize);
174 ASSERT_EQ(tb.GetBufSize(), tlvsize);
175 tb.Clear();
176 ASSERT_EQ(tb.GetBufSize(), 0);
177
178 delete[] tlv;
179 }
180
181 HWTEST_F(HdcBaseTest, TlvBuf_Append_001, TestSize.Level0)
182 {
183 uint8_t val[10] = { 0xAC };
184 TlvBuf tb;
185 ASSERT_EQ(tb.GetBufSize(), 0);
186
187 ASSERT_EQ(tb.Append(1, sizeof(val), val), true);
188 ASSERT_EQ(tb.GetBufSize(), TlvSize(sizeof(val)));
189
190 // duplicate, append failed, nothing changed
191 ASSERT_EQ(tb.Append(1, sizeof(val), val), false);
192 ASSERT_EQ(tb.GetBufSize(), TlvSize(sizeof(val)));
193
194 ASSERT_EQ(tb.Append(2, sizeof(val), val), true);
195 ASSERT_EQ(tb.GetBufSize(), TlvSize(sizeof(val)) * 2);
196 }
197
198 HWTEST_F(HdcBaseTest, TlvBuf_Append_002, TestSize.Level0)
199 {
200 uint32_t tag = 1;
201 string val = "hello world!";
202 TlvBuf tb;
203 ASSERT_EQ(tb.GetBufSize(), 0);
204
205 ASSERT_EQ(tb.Append(tag, val), true);
206 ASSERT_EQ(tb.GetBufSize(), TlvSize(val.size()));
207 }
208
209 HWTEST_F(HdcBaseTest, TlvBuf_Append_003, TestSize.Level0)
210 {
211 TlvBuf tb;
212
213 ASSERT_EQ(tb.Append(1, 0, nullptr), false);
214 ASSERT_EQ(tb.GetBufSize(), 0);
215
216 ASSERT_EQ(tb.Append(1, TLV_VALUE_MAX_LEN + 1, nullptr), false);
217 ASSERT_EQ(tb.GetBufSize(), 0);
218
219 ASSERT_EQ(tb.Append(1, TLV_VALUE_MAX_LEN, nullptr), false);
220 ASSERT_EQ(tb.GetBufSize(), 0);
221 }
222
223 HWTEST_F(HdcBaseTest, TlvBuf_CopyToBuf_001, TestSize.Level0)
224 {
225 uint32_t tag = 1;
226 const uint32_t len = 10;
227 uint8_t val[len] = { 0xAC };
228 TlvBuf tb;
229 ASSERT_EQ(tb.GetBufSize(), 0);
230
231 ASSERT_EQ(tb.Append(tag, len, val), true);
232 uint32_t size = tb.GetBufSize();
233 ASSERT_EQ(size, TlvSize(len));
234
235 uint8_t *buf = new (std::nothrow) uint8_t[size];
236 ASSERT_EQ(tb.CopyToBuf(buf, size - 1), false);
237 ASSERT_EQ(tb.CopyToBuf(nullptr, size), false);
238
239 ASSERT_EQ(tb.CopyToBuf(buf, size), true);
240 ASSERT_EQ(*(uint32_t *)buf, tag);
241 ASSERT_EQ(*(uint32_t *)(buf + sizeof(tag)), len);
242 ASSERT_EQ(memcmp(buf + TLV_HEAD_SIZE, val, len), 0);
243 }
244
245 HWTEST_F(HdcBaseTest, TlvBuf_FindTlv_001, TestSize.Level0)
246 {
247 uint32_t tag = 1;
248 const uint32_t len = 10;
249 uint8_t val[len] = { 0xAC };
250 TlvBuf tb;
251 ASSERT_EQ(tb.GetBufSize(), 0);
252
253 ASSERT_EQ(tb.Append(tag, len, val), true);
254 ASSERT_EQ(tb.GetBufSize(), TlvSize(len));
255
256 uint32_t ftag = 2;
257 uint32_t flen = 1;
258 uint8_t *fval = nullptr;
259 ASSERT_EQ(tb.FindTlv(ftag, flen, fval), false);
260 ASSERT_EQ(flen, 1);
261 ASSERT_EQ(fval, nullptr);
262 ftag = 1;
263 ASSERT_EQ(tb.FindTlv(ftag, flen, fval), true);
264 ASSERT_EQ(flen, len);
265 ASSERT_EQ(memcmp(fval, val, len), 0);
266
267 delete[] fval;
268 }
269
270 HWTEST_F(HdcBaseTest, TlvBuf_FindTlv_002, TestSize.Level0)
271 {
272 uint32_t tag = 1;
273 string val = "hello world!";
274 TlvBuf tb;
275 ASSERT_EQ(tb.GetBufSize(), 0);
276
277 ASSERT_EQ(tb.Append(tag, val), true);
278 ASSERT_EQ(tb.GetBufSize(), TlvSize(val.size()));
279
280 string fval;
281 ASSERT_EQ(tb.FindTlv(tag, fval), true);
282 ASSERT_EQ(val, fval);
283 }
284
285 HWTEST_F(HdcBaseTest, TlvBuf_ContainInvalidTag_001, TestSize.Level0)
286 {
287 std::set<uint32_t> validtags = { 1, 2, 3 };
288 std::vector<uint32_t> tags = { 1, 2, 3 };
289 std::vector<uint32_t> sizes = { 4, 4, 4 };
290 uint32_t tlvsize = 0;
291 uint8_t *tlv = this->BuildTlv(tags, sizes, 0xAB, tlvsize);
292 ASSERT_NE(tlv, nullptr);
293 TlvBuf tb(tlv, tlvsize, validtags);
294 ASSERT_EQ(tb.GetBufSize(), tlvsize);
295
296 ASSERT_EQ(tb.ContainInvalidTag(), false);
297
298 uint32_t tag = 5;
299 const uint32_t len = 10;
300 uint8_t val[len] = { 0xAC };
301 ASSERT_EQ(tb.Append(tag, len, val), true);
302 ASSERT_EQ(tb.ContainInvalidTag(), true);
303
304 delete[] tlv;
305 }
306
307 HWTEST_F(HdcBaseTest, TlvBuf_ContainInvalidTag_002, TestSize.Level0)
308 {
309 std::set<uint32_t> validtags = { 1, 2 };
310 std::vector<uint32_t> tags = { 1, 2, 3 };
311 std::vector<uint32_t> sizes = { 4, 4, 4 };
312 uint32_t tlvsize = 0;
313 uint8_t *tlv = this->BuildTlv(tags, sizes, 0xAB, tlvsize);
314 ASSERT_NE(tlv, nullptr);
315 TlvBuf tb(tlv, tlvsize, validtags);
316 ASSERT_EQ(tb.GetBufSize(), tlvsize);
317
318 ASSERT_EQ(tb.ContainInvalidTag(), true);
319
320 delete[] tlv;
321 }
322
323 HWTEST_F(HdcBaseTest, TlvBuf_Display_001, TestSize.Level0)
324 {
325 std::vector<uint32_t> tags = { 1 };
326 std::vector<uint32_t> sizes = { 1 };
327 uint32_t tlvsize = 0;
328 uint8_t *tlv = this->BuildTlv(tags, sizes, 0xAB, tlvsize);
329 ASSERT_NE(tlv, nullptr);
330
331 TlvBuf tb(tlv, tlvsize);
332 ASSERT_EQ(tb.GetBufSize(), tlvsize);
333 tb.Display();
334
335 delete[] tlv;
336 }
337
338 } // namespace Hdc
339