• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
17 #define LOG_TAG "TlvUtilTest"
18 
19 #include "tlv_util.h"
20 #include <gtest/gtest.h>
21 #include "unified_data.h"
22 #include "logger.h"
23 #include "plain_text.h"
24 #include "html.h"
25 #include "link.h"
26 #include "int_wrapper.h"
27 #include "system_defined_appitem.h"
28 #include "application_defined_record.h"
29 #include "file.h"
30 #include "system_defined_form.h"
31 #include "system_defined_pixelmap.h"
32 #include "system_defined_record.h"
33 #include "udmf_conversion.h"
34 #include "unified_data_helper.h"
35 #include "unified_meta.h"
36 #include "unified_record.h"
37 #include "unified_types.h"
38 
39 using namespace testing::ext;
40 using namespace OHOS::UDMF;
41 using namespace OHOS;
42 
43 namespace OHOS::Test {
44 class TlvUtilTest : public testing::Test {
45 public:
46     static void SetUpTestCase(void);
47 
48     static void TearDownTestCase(void);
49 
50     void SetUp();
51 
52     void TearDown();
53 };
54 
SetUpTestCase(void)55 void TlvUtilTest::SetUpTestCase(void) {}
TearDownTestCase(void)56 void TlvUtilTest::TearDownTestCase(void) {}
SetUp(void)57 void TlvUtilTest::SetUp(void) {}
TearDown(void)58 void TlvUtilTest::TearDown(void) {}
59 
60 /* *
61  * @tc.name: CountBufferSize_001
62  * @tc.desc: test fundamental for countBufferSize
63  * @tc.type: FUNC
64  */
65 HWTEST_F(TlvUtilTest, CountBufferSize_001, TestSize.Level1)
66 {
67     LOG_INFO(UDMF_TEST, "CountBufferSize_001 begin.");
68     std::vector<uint8_t> dataBytes;
69     auto tlvObject = TLVObject(dataBytes);
70     uint8_t num1 = 1;
71     EXPECT_EQ(sizeof(TLVHead) + sizeof(num1), TLVUtil::CountBufferSize(num1, tlvObject)); // 7
72     uint16_t num2 = 1;
73     EXPECT_EQ(sizeof(TLVHead) + sizeof(num2), TLVUtil::CountBufferSize(num2, tlvObject)); // 8
74     uint32_t num3 = 1;
75     EXPECT_EQ(sizeof(TLVHead) + sizeof(num3), TLVUtil::CountBufferSize(num3, tlvObject)); // 10
76     int16_t num4 = 1;
77     EXPECT_EQ(sizeof(TLVHead) + sizeof(num4), TLVUtil::CountBufferSize(num4, tlvObject)); // 8
78     int32_t num5 = 1;
79     EXPECT_EQ(sizeof(TLVHead) + sizeof(num5), TLVUtil::CountBufferSize(num5, tlvObject)); // 10
80     bool boolean = true;
81     EXPECT_EQ(sizeof(TLVHead) + sizeof(boolean), TLVUtil::CountBufferSize(boolean, tlvObject)); // 7
82     double doubleNum = 1;
83     EXPECT_EQ(sizeof(TLVHead) + sizeof(doubleNum), TLVUtil::CountBufferSize(doubleNum, tlvObject)); // 14
84     EXPECT_EQ(sizeof(TLVHead), TLVUtil::CountBufferSize(std::nullptr_t(), tlvObject));              // 6
85     std::monostate monostate;
86     EXPECT_EQ(sizeof(TLVHead), TLVUtil::CountBufferSize(monostate, tlvObject)); // 6
87     std::string str = "abc";
88     EXPECT_EQ(sizeof(TLVHead) + str.size(), TLVUtil::CountBufferSize(str, tlvObject)); // 9
89     UDType type = XML;
90     EXPECT_EQ(sizeof(TLVHead) + sizeof(type), TLVUtil::CountBufferSize(type, tlvObject)); // 10
91     DataStatus status = HISTORY;
92     EXPECT_EQ(sizeof(TLVHead) + sizeof(status), TLVUtil::CountBufferSize(status, tlvObject)); // 10
93     std::vector<uint8_t> u8Vector = { 1, 1, 1 };
94     EXPECT_EQ(sizeof(TLVHead) + u8Vector.size(), TLVUtil::CountBufferSize(u8Vector, tlvObject)); // 9
95     std::shared_ptr<uint8_t> ptr;
96     EXPECT_EQ(sizeof(TLVHead), TLVUtil::CountBufferSize(ptr, tlvObject)); // 6
97     ptr = std::make_shared<uint8_t>(1);
98     EXPECT_EQ(sizeof(TLVHead) + 1, TLVUtil::CountBufferSize(ptr, tlvObject)); // 7
99     LOG_INFO(UDMF_TEST, "CountBufferSize_001 end.");
100 }
101 
102 /* *
103  * @tc.name: CountBufferSize_002
104  * @tc.desc: test STL for countBufferSize
105  * @tc.type: FUNC
106  */
107 HWTEST_F(TlvUtilTest, CountBufferSize_002, TestSize.Level1)
108 {
109     LOG_INFO(UDMF_TEST, "CountBufferSize_002 begin.");
110     std::vector<uint8_t> dataBytes;
111     auto tlvObject = TLVObject(dataBytes);
112     Privilege privilege1;
113     privilege1.readPermission = "111";
114     Privilege privilege2;
115     privilege2.readPermission = "111";
116     privilege2.writePermission = "xx";
117     std::vector<Privilege> privilegeVector{ privilege1, privilege2 };
118     EXPECT_EQ(10 * sizeof(TLVHead) + 2 * sizeof(uint32_t) + sizeof(size_t) + 8,
119         TLVUtil::CountBufferSize(privilegeVector, tlvObject)); // 80
120 
121     Object object;
122     std::map<std::string, ValueType> map;
123     map["keyString"] = "value";
124     double key = 12;
125     map["keyNum"] = key;
126     object.value_ = map;
127     EXPECT_EQ(12 * sizeof(TLVHead) + 36, TLVUtil::CountBufferSize(object, tlvObject)); // 108
128     LOG_INFO(UDMF_TEST, "CountBufferSize_002 end.");
129 }
130 
131 /* *
132  * @tc.name: CountBufferSize_003
133  * @tc.desc: test udmf for countBufferSize
134  * @tc.type: FUNC
135  */
136 HWTEST_F(TlvUtilTest, CountBufferSize_003, TestSize.Level1)
137 {
138     LOG_INFO(UDMF_TEST, "CountBufferSize_003 begin.");
139     std::vector<uint8_t> dataBytes;
140     auto tlvObject = TLVObject(dataBytes);
141 
142     std::shared_ptr<Object> object = std::make_shared<Object>();
143     std::map<std::string, ValueType> map;
144     map["uniformDataType"] = UtdUtils::GetUtdIdFromUtdEnum(UDType::PLAIN_TEXT);
145     map["textContent"] = "content";
146     map["abstract"] = "abstract";
147     object->value_ = map;
148     std::shared_ptr<UnifiedRecord> record = std::make_shared<PlainText>(PLAIN_TEXT, object);
149 
150     std::vector<std::shared_ptr<UnifiedRecord>> vector = { record };
151     UnifiedData data;
152     data.SetRecords(vector);
153     std::vector<UnifiedData> unifiedData = { data };
154     auto size = TLVUtil::CountBufferSize(unifiedData, tlvObject);
155     EXPECT_EQ(tlvObject.GetTotal(), size); // 269
156     LOG_INFO(UDMF_TEST, "CountBufferSize_003 end.");
157 }
158 
159 /* *
160  * @tc.name: CountBufferSize_004
161  * @tc.desc: test other for countBufferSize
162  * @tc.type: FUNC
163  */
164 HWTEST_F(TlvUtilTest, CountBufferSize_004, TestSize.Level1)
165 {
166     LOG_INFO(UDMF_TEST, "CountBufferSize_004 begin.");
167     std::vector<uint8_t> dataBytes;
168     auto tlvObject = TLVObject(dataBytes);
169 
170     UnifiedKey key;
171     key.key = "123456";
172     key.intention = "DRAG";
173     key.bundleName = "com.xxx";
174     EXPECT_EQ(5 * sizeof(TLVHead) + 17, TLVUtil::CountBufferSize(key, tlvObject));
175 
176     Privilege privilege;
177     EXPECT_EQ(4 * sizeof(TLVHead) + sizeof(int32_t), TLVUtil::CountBufferSize(privilege, tlvObject));
178 
179     Runtime runtime;
180     EXPECT_EQ(21 * sizeof(TLVHead) + sizeof(bool) + sizeof(size_t) + 2 * sizeof(int64_t) + 3 * sizeof(int32_t) +
181         2 * sizeof(uint32_t),
182         TLVUtil::CountBufferSize(runtime, tlvObject));
183     LOG_INFO(UDMF_TEST, "CountBufferSize_004 end.");
184 }
185 
186 /* *
187  * @tc.name: WritingAndReading_001
188  * @tc.desc: test fundamental for Writing And Reading
189  * @tc.type: FUNC
190  */
191 HWTEST_F(TlvUtilTest, WritingAndReading_001, TestSize.Level1)
192 {
193     LOG_INFO(UDMF_TEST, "WritingAndReading_001 begin.");
194     std::vector<uint8_t> dataBytes;
195     auto tlvObject = TLVObject(dataBytes);
196     uint16_t num1 = 1;
197     auto result = TLVUtil::Writing(num1, tlvObject, TAG::TAG_UINT16);
198     int8_t num2 = 2;
199     result = TLVUtil::Writing(num2, tlvObject, TAG::TAG_INT8) && result;
200     uint32_t num3 = 3;
201     result = TLVUtil::Writing(num3, tlvObject, TAG::TAG_UINT32) && result;
202     int16_t num4 = 4;
203     result = TLVUtil::Writing(num4, tlvObject, TAG::TAG_INT16) && result;
204     int32_t num5 = 5;
205     result = result = TLVUtil::Writing(num5, tlvObject, TAG::TAG_INT32) && result;
206     bool boolean = true;
207     result = TLVUtil::Writing(boolean, tlvObject, TAG::TAG_BOOL) && result;
208     result = TLVUtil::Writing(std::nullptr_t(), tlvObject, TAG::TAG_NULL);
209     std::monostate monostate;
210     result = TLVUtil::Writing(monostate, tlvObject, TAG::TAG_MONOSTATE) && result;
211     std::string str = "abc";
212     result = TLVUtil::Writing(str, tlvObject, TAG::TAG_STRING) && result;
213     UDType type = XML;
214     result = TLVUtil::Writing(type, tlvObject, TAG::TAG_UD_TYPE) && result;
215     DataStatus status = HISTORY;
216     result = TLVUtil::Writing(status, tlvObject, TAG::TAG_DATA_STATUS) && result;
217     std::vector<uint8_t> u8Vector = { 1, 2, 3 };
218     result = TLVUtil::Writing(u8Vector, tlvObject, TAG::TAG_UINT8) && result;
219     EXPECT_TRUE(result);
220 
221     uint16_t num1Result;
222     int8_t num2Result;
223     uint32_t num3Result;
224     int16_t num4Result;
225     int32_t num5Result;
226     bool booleanResult;
227     std::string strResult;
228     UDType typeResult;
229     DataStatus statusResult;
230     std::vector<uint8_t> u8VectorResult;
231 
232     tlvObject.ResetCursor();
233     TLVUtil::ReadTlv(statusResult, tlvObject, TAG::TAG_DATA_STATUS);
234     tlvObject.ResetCursor();
235     EXPECT_EQ(status, statusResult);
236 
237     tlvObject.ResetCursor();
238     TLVUtil::ReadTlv(typeResult, tlvObject, TAG::TAG_UD_TYPE);
239     EXPECT_EQ(type, typeResult);
240 
241     tlvObject.ResetCursor();
242     TLVUtil::ReadTlv(strResult, tlvObject, TAG::TAG_STRING);
243     EXPECT_EQ(str, strResult);
244 
245     tlvObject.ResetCursor();
246     TLVUtil::ReadTlv(booleanResult, tlvObject, TAG::TAG_BOOL);
247     EXPECT_EQ(boolean, booleanResult);
248 
249     tlvObject.ResetCursor();
250     TLVUtil::ReadTlv(num5Result, tlvObject, TAG::TAG_INT32);
251     EXPECT_EQ(num5, num5Result);
252 
253     tlvObject.ResetCursor();
254     TLVUtil::ReadTlv(num4Result, tlvObject, TAG::TAG_INT16);
255     EXPECT_EQ(num4, num4Result);
256 
257     tlvObject.ResetCursor();
258     TLVUtil::ReadTlv(num3Result, tlvObject, TAG::TAG_UINT32);
259     EXPECT_EQ(num3, num3Result);
260 
261     tlvObject.ResetCursor();
262     TLVUtil::ReadTlv(num2Result, tlvObject, TAG::TAG_INT8);
263     EXPECT_EQ(num2, num2Result);
264 
265     tlvObject.ResetCursor();
266     TLVUtil::ReadTlv(num1Result, tlvObject, TAG::TAG_UINT16);
267     EXPECT_EQ(num1, num1Result);
268 
269     tlvObject.ResetCursor();
270     TLVUtil::ReadTlv(u8VectorResult, tlvObject, TAG::TAG_UINT8);
271     for (int i = 0; i < 3; i++) {
272         EXPECT_EQ(u8Vector[i], u8VectorResult[i]);
273     }
274     LOG_INFO(UDMF_TEST, "WritingAndReading_001 end.");
275 }
276 
277 /* *
278  * @tc.name: WritingAndReading_002
279  * @tc.desc: test Runtime for Writing And Reading
280  * @tc.type: FUNC
281  */
282 HWTEST_F(TlvUtilTest, WritingAndReading_002, TestSize.Level1)
283 {
284     LOG_INFO(UDMF_TEST, "WritingAndReading_002 begin.");
285     UnifiedKey key;
286     key.key = "123456";
287     Privilege privilege;
288     privilege.readPermission = "read";
289     privilege.tokenId = 333;
290     Privilege privilege2;
291     privilege2.writePermission = "read";
292     privilege2.tokenId = 444;
293     Runtime runtime;
294     runtime.dataStatus = DELETED;
295     runtime.key = key;
296     runtime.privileges.push_back(privilege);
297     runtime.privileges.push_back(privilege2);
298     runtime.createTime = 1;
299     runtime.dataVersion = 3;
300     runtime.createPackage = "package";
301     runtime.isPrivate = true;
302     runtime.appId = "appId";
303 
304     std::vector<uint8_t> dataBytes;
305     auto tlvObject = TLVObject(dataBytes);
306     EXPECT_TRUE(TLVUtil::Writing(runtime, tlvObject, TAG::TAG_RUNTIME));
307 
308     tlvObject.ResetCursor();
309     Runtime runtimeResult;
310     EXPECT_TRUE(TLVUtil::ReadTlv(runtimeResult, tlvObject, TAG::TAG_RUNTIME));
311     EXPECT_EQ(runtime.key.key, runtimeResult.key.key);
312     EXPECT_EQ(runtime.key.key, runtimeResult.key.key);
313     EXPECT_EQ(runtime.dataStatus, runtimeResult.dataStatus);
314     EXPECT_EQ(runtime.createTime, runtimeResult.createTime);
315     EXPECT_EQ(runtime.dataVersion, runtimeResult.dataVersion);
316     EXPECT_EQ(runtime.createPackage, runtimeResult.createPackage);
317     EXPECT_EQ(runtime.isPrivate, runtimeResult.isPrivate);
318     EXPECT_EQ(runtime.privileges[0].readPermission, runtimeResult.privileges[0].readPermission);
319     EXPECT_EQ(runtime.privileges[0].tokenId, runtimeResult.privileges[0].tokenId);
320     EXPECT_EQ(runtime.privileges[1].writePermission, runtimeResult.privileges[1].writePermission);
321     EXPECT_EQ(runtime.privileges[1].tokenId, runtimeResult.privileges[1].tokenId);
322     EXPECT_EQ(runtime.appId, runtimeResult.appId);
323 
324     LOG_INFO(UDMF_TEST, "WritingAndReading_002 end.");
325 }
326 
327 /* *
328  * @tc.name: WritingAndReading_003
329  * @tc.desc: test UnifiedData for Writing And Reading
330  * @tc.type: FUNC
331  */
332 HWTEST_F(TlvUtilTest, WritingAndReading_003, TestSize.Level1)
333 {
334     LOG_INFO(UDMF_TEST, "WritingAndReading_003 begin.");
335 
336     std::map<std::string, ValueType> value;
337     value["fileType"] = "File Type";
338     value["fileUri"] = "File Uri";
339     std::shared_ptr<Object> obj = std::make_shared<Object>();
340     obj->value_ = value;
341     std::shared_ptr<UnifiedRecord> fileUri = std::make_shared<UnifiedRecord>(UDType::FILE_URI, obj);
342 
343     std::shared_ptr<UnifiedRecord> plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, "this is a content");
344     std::shared_ptr<UnifiedRecord> html = std::make_shared<Html>(UDType::HTML, "this is a HTML content");
345 
346     std::vector<std::shared_ptr<UnifiedRecord>> records = { fileUri, plainText, html };
347 
348     UnifiedData data1;
349     data1.SetRecords(records);
350 
351     std::shared_ptr<SystemDefinedAppItem> appItem =
352         std::make_shared<SystemDefinedAppItem>(UDType::SYSTEM_DEFINED_APP_ITEM, "OTHER param");
353     appItem->SetAppId("com.demo");
354     std::shared_ptr<ApplicationDefinedRecord> defineRecord =
355         std::make_shared<ApplicationDefinedRecord>(UDType::APPLICATION_DEFINED_RECORD, "OTHER param");
356     std::vector<uint8_t> u8Vector = { 1, 2, 3, 4 };
357     defineRecord->SetRawData(u8Vector);
358     std::shared_ptr<UnifiedRecord> file = std::make_shared<File>(UDType::FILE, "this is a oriUri");
359 
360     std::vector<std::shared_ptr<UnifiedRecord>> records2 = { appItem, defineRecord, file };
361 
362     UnifiedData data2;
363     data2.SetRecords(records2);
364 
365     std::vector<UnifiedData> datas = { data1, data2 };
366 
367     std::vector<uint8_t> dataBytes;
368     auto tlvObject = TLVObject(dataBytes);
369 
370     UdmfConversion::InitValueObject(datas);
371     EXPECT_TRUE(TLVUtil::Writing(datas, tlvObject, TAG::TAG_UNIFIED_DATA));
372 
373     tlvObject.ResetCursor();
374     std::vector<UnifiedData> datasResult;
375 
376     EXPECT_TRUE(TLVUtil::ReadTlv(datasResult, tlvObject, TAG::TAG_UNIFIED_DATA));
377     EXPECT_EQ(2, datasResult.size());
378     UdmfConversion::ConvertRecordToSubclass(datasResult);
379 
380     auto recordsResult = datasResult[0].GetRecords();
381     EXPECT_EQ(3, recordsResult.size());
382 
383     auto fileUriResult = recordsResult[0];
384     EXPECT_EQ(UDType::FILE_URI, fileUriResult->GetType());
385     auto fileUriValue = fileUriResult->GetValue();
386     EXPECT_TRUE(std::holds_alternative<std::shared_ptr<Object>>(fileUriValue));
387     auto fileUriObj = std::get<std::shared_ptr<Object>>(fileUriValue);
388     EXPECT_EQ("File Uri", std::get<std::string>(fileUriObj->value_["fileUri"]));
389     EXPECT_EQ("File Type", std::get<std::string>(fileUriObj->value_["fileType"]));
390 
391     auto plainTextResult = recordsResult[1];
392     EXPECT_EQ(UDType::PLAIN_TEXT, plainTextResult->GetType());
393     auto plainTextSubclass = std::static_pointer_cast<PlainText>(plainTextResult);
394     EXPECT_EQ("this is a content", plainTextSubclass->GetContent());
395     auto plainTextValue = plainTextSubclass->GetValue();
396     EXPECT_TRUE(std::holds_alternative<std::string>(plainTextValue));
397 
398     auto htmlResult = recordsResult[2];
399     EXPECT_EQ(UDType::HTML, htmlResult->GetType());
400     auto htmlSubclass = std::static_pointer_cast<Html>(htmlResult);
401     EXPECT_EQ("this is a HTML content", htmlSubclass->GetHtmlContent());
402     auto htmlValue = htmlSubclass->GetValue();
403     EXPECT_TRUE(std::holds_alternative<std::string>(htmlValue));
404 
405     auto recordsResult2 = datasResult[1].GetRecords();
406     EXPECT_EQ(3, recordsResult2.size());
407     auto appItemResult = recordsResult2[0];
408     EXPECT_EQ(UDType::SYSTEM_DEFINED_APP_ITEM, appItemResult->GetType());
409     auto appItemSubclass = std::static_pointer_cast<SystemDefinedAppItem>(appItemResult);
410     EXPECT_EQ("com.demo", appItemSubclass->GetAppId());
411     auto appItemValue = appItemSubclass->GetValue();
412     EXPECT_TRUE(std::holds_alternative<std::string>(appItemValue));
413 
414     auto defineRecordResult = recordsResult2[1];
415     EXPECT_EQ(UDType::APPLICATION_DEFINED_RECORD, defineRecordResult->GetType());
416     auto adefineRecordSubclass = std::static_pointer_cast<ApplicationDefinedRecord>(defineRecordResult);
417     auto u8VectorResult = adefineRecordSubclass->GetRawData();
418     EXPECT_EQ(4, u8VectorResult.size());
419     auto adefineRecordValue = adefineRecordSubclass->GetValue();
420     EXPECT_TRUE(std::holds_alternative<std::string>(adefineRecordValue));
421 
422     auto fileResult = recordsResult2[2];
423     EXPECT_EQ(UDType::FILE, fileResult->GetType());
424     auto fileSubclass = std::static_pointer_cast<File>(fileResult);
425     EXPECT_EQ(16, fileSubclass->GetSize());
426     auto fileValue = fileSubclass->GetValue();
427     EXPECT_TRUE(std::holds_alternative<std::string>(fileValue));
428 
429     LOG_INFO(UDMF_TEST, "WritingAndReading_003 end.");
430 }
431 
432 /* *
433  * @tc.name: WritingAndReading_004
434  * @tc.desc: test UnifiedData for Writing And Reading
435  * @tc.type: FUNC
436  */
437 HWTEST_F(TlvUtilTest, WritingAndReading_004, TestSize.Level1)
438 {
439     LOG_INFO(UDMF_TEST, "WritingAndReading_004 begin.");
440 
441     uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
442     OHOS::Media::InitializationOptions opts = { { 5, 7 },
443         Media::PixelFormat::ARGB_8888,
444         Media::PixelFormat::ARGB_8888 };
445     std::unique_ptr<OHOS::Media::PixelMap> pixelMap =
446         OHOS::Media::PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
447     std::shared_ptr<OHOS::Media::PixelMap> pixelMapIn = move(pixelMap);
448     std::map<std::string, ValueType> value;
449     value["pixelMap"] = pixelMapIn;
450     std::shared_ptr<Object> obj = std::make_shared<Object>();
451     obj->value_ = value;
452     std::shared_ptr<UnifiedRecord> pixelMapRecord =
453         std::make_shared<SystemDefinedPixelMap>(UDType::SYSTEM_DEFINED_PIXEL_MAP, obj);
454 
455     std::shared_ptr<SystemDefinedForm> form =
456         std::make_shared<SystemDefinedForm>(UDType::SYSTEM_DEFINED_FORM, "Other parm");
457     form->SetFormName("HAPPY DAY");
458 
459     UDDetails details;
460     details.emplace("name", "ZhangSan");
461     details.emplace("age", 30);
462     details.emplace("isFemal", true);
463     std::shared_ptr<SystemDefinedRecord> definedRecord =
464         std::make_shared<SystemDefinedRecord>(UDType::SYSTEM_DEFINED_RECORD, "Other parm");
465     definedRecord->SetDetails(details);
466     std::vector<std::shared_ptr<UnifiedRecord>> records = { pixelMapRecord, form, definedRecord };
467 
468     UnifiedData data;
469     data.SetRecords(records);
470 
471     std::vector<UnifiedData> datas = { data };
472 
473     std::vector<uint8_t> dataBytes;
474     auto tlvObject = TLVObject(dataBytes);
475 
476     UdmfConversion::InitValueObject(datas);
477     EXPECT_TRUE(TLVUtil::Writing(datas, tlvObject, TAG::TAG_UNIFIED_DATA));
478 
479     tlvObject.ResetCursor();
480     std::vector<UnifiedData> datasResult;
481 
482     EXPECT_TRUE(TLVUtil::ReadTlv(datasResult, tlvObject, TAG::TAG_UNIFIED_DATA));
483     EXPECT_EQ(1, datasResult.size());
484     UdmfConversion::ConvertRecordToSubclass(datasResult);
485 
486     auto recordsResult = datasResult[0].GetRecords();
487     EXPECT_EQ(3, recordsResult.size());
488 
489     auto pixelMapRecordResult = recordsResult[0];
490     EXPECT_EQ(UDType::SYSTEM_DEFINED_PIXEL_MAP, pixelMapRecordResult->GetType());
491     auto pixelMapValue = pixelMapRecordResult->GetValue();
492     EXPECT_TRUE(std::holds_alternative<std::shared_ptr<Object>>(pixelMapValue));
493     auto pixelMapObj = std::get<std::shared_ptr<Object>>(pixelMapValue);
494     EXPECT_TRUE(std::holds_alternative<std::shared_ptr<OHOS::Media::PixelMap>>(pixelMapObj->value_["pixelMap"]));
495     auto piexelMapResult = std::get<std::shared_ptr<OHOS::Media::PixelMap>>(pixelMapObj->value_["pixelMap"]);
496     EXPECT_EQ(7, piexelMapResult->GetHeight());
497 
498     auto formResult = recordsResult[1];
499     EXPECT_EQ(UDType::SYSTEM_DEFINED_FORM, formResult->GetType());
500     auto formSubclass = std::static_pointer_cast<SystemDefinedForm>(formResult);
501     EXPECT_EQ("HAPPY DAY", formSubclass->GetFormName());
502     auto formValue = formSubclass->GetValue();
503     EXPECT_TRUE(std::holds_alternative<std::string>(formValue));
504 
505     auto definedRecordResult = recordsResult[2];
506     EXPECT_EQ(UDType::SYSTEM_DEFINED_RECORD, definedRecordResult->GetType());
507     auto definedRecordSubclass = std::static_pointer_cast<SystemDefinedRecord>(definedRecordResult);
508     auto detailsRecord = definedRecordSubclass->GetDetails();
509     EXPECT_EQ("ZhangSan", std::get<std::string>(detailsRecord["name"]));
510     EXPECT_EQ(30, std::get<int32_t>(detailsRecord["age"]));
511     EXPECT_TRUE(std::get<bool>(detailsRecord["isFemal"]));
512     auto definedRecordValue = definedRecordSubclass->GetValue();
513     EXPECT_TRUE(std::holds_alternative<std::string>(definedRecordValue));
514 
515     LOG_INFO(UDMF_TEST, "WritingAndReading_004 end.");
516 }
517 
518 /* *
519  * @tc.name: WritingAndReading_005
520  * @tc.desc: test Want for Writing And Reading
521  * @tc.type: FUNC
522  */
523 HWTEST_F(TlvUtilTest, WritingAndReading_005, TestSize.Level1)
524 {
525     LOG_INFO(UDMF_TEST, "WritingAndReading_005 begin.");
526     std::shared_ptr<OHOS::AAFwk::Want> want = std::make_shared<OHOS::AAFwk::Want>();
527     std::string idKey = "id";
528     int32_t idValue = 123;
529     want->SetParam(idKey, idValue);
530     std::map<std::string, ValueType> value;
531     value["want"] = want;
532     std::shared_ptr<Object> obj = std::make_shared<Object>();
533     obj->value_ = value;
534 
535     std::vector<uint8_t> dataBytes;
536     auto tlvObject = TLVObject(dataBytes);
537 
538     EXPECT_TRUE(TLVUtil::Writing(obj, tlvObject, TAG::TAG_OBJECT_VALUE));
539     tlvObject.ResetCursor();
540     std::shared_ptr<Object> objResult = std::make_shared<Object>();
541     EXPECT_TRUE(TLVUtil::ReadTlv(objResult, tlvObject, TAG::TAG_OBJECT_VALUE));
542     auto valueResult = objResult->value_;
543     EXPECT_TRUE(std::holds_alternative<std::shared_ptr<OHOS::AAFwk::Want>>(valueResult["want"]));
544     auto wantResult = std::get<std::shared_ptr<OHOS::AAFwk::Want>>(valueResult["want"]);
545     EXPECT_EQ(idValue, wantResult->GetIntParam(idKey, 0));
546     LOG_INFO(UDMF_TEST, "WritingAndReading_005 end.");
547 }
548 
549 /* *
550  * @tc.name: WritingAndReading_008
551  * @tc.desc: test Runtime for Writing And Reading
552  * @tc.type: FUNC
553  */
554 HWTEST_F(TlvUtilTest, WritingAndReading_008, TestSize.Level1)
555 {
556     LOG_INFO(UDMF_TEST, "WritingAndReading_002 begin.");
557     UnifiedKey key;
558     key.key = "123456";
559     Privilege privilege;
560     privilege.readPermission = "read";
561     privilege.tokenId = 333;
562     Privilege privilege2;
563     privilege2.writePermission = "read";
564     privilege2.tokenId = 444;
565     Runtime runtime;
566     runtime.dataStatus = DELETED;
567     runtime.key = key;
568     runtime.privileges.push_back(privilege);
569     runtime.privileges.push_back(privilege2);
570     runtime.createTime = 1;
571     runtime.dataVersion = 3;
572     runtime.createPackage = "package";
573     runtime.isPrivate = true;
574     runtime.appId = "appId";
575 
576     std::vector<uint8_t> dataBytes;
577     auto tlvObject = TLVObject(dataBytes);
578     EXPECT_TRUE(TLVUtil::Writing(runtime, tlvObject, TAG::TAG_APP_ID));
579 
580     tlvObject.ResetCursor();
581     Runtime runtimeResult;
582     EXPECT_TRUE(TLVUtil::ReadTlv(runtimeResult, tlvObject, TAG::TAG_APP_ID));
583     EXPECT_EQ(runtime.key.key, runtimeResult.key.key);
584     EXPECT_EQ(runtime.key.key, runtimeResult.key.key);
585     EXPECT_EQ(runtime.dataStatus, runtimeResult.dataStatus);
586     EXPECT_EQ(runtime.createTime, runtimeResult.createTime);
587     EXPECT_EQ(runtime.dataVersion, runtimeResult.dataVersion);
588     EXPECT_EQ(runtime.createPackage, runtimeResult.createPackage);
589     EXPECT_EQ(runtime.isPrivate, runtimeResult.isPrivate);
590     EXPECT_EQ(runtime.appId, runtimeResult.appId);
591     EXPECT_EQ(runtime.privileges[0].readPermission, runtimeResult.privileges[0].readPermission);
592     EXPECT_EQ(runtime.privileges[0].tokenId, runtimeResult.privileges[0].tokenId);
593     EXPECT_EQ(runtime.privileges[1].writePermission, runtimeResult.privileges[1].writePermission);
594     EXPECT_EQ(runtime.privileges[1].tokenId, runtimeResult.privileges[1].tokenId);
595 
596     LOG_INFO(UDMF_TEST, "WritingAndReading_008 end.");
597 }
598 
599 /* *
600  * @tc.name: WritingAndReadingFile_001
601  * @tc.desc: test Unified Data for Writing And Reading
602  * @tc.type: FUNC
603  */
604 HWTEST_F(TlvUtilTest, WritingAndReadingFile_001, TestSize.Level1)
605 {
606     LOG_INFO(UDMF_TEST, "WritingAndReadingFile_001 begin.");
607     std::map<std::string, ValueType> value;
608     value["fileType"] = "File Type";
609     value["fileUri"] = "File Uri";
610     std::shared_ptr<Object> obj = std::make_shared<Object>();
611     obj->value_ = value;
612     std::shared_ptr<UnifiedRecord> fileUri = std::make_shared<UnifiedRecord>(UDType::FILE_URI, obj);
613 
614     std::shared_ptr<UnifiedRecord> plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, "this is a content");
615     std::shared_ptr<UnifiedRecord> html = std::make_shared<Html>(UDType::HTML, "this is a HTML content");
616 
617     std::vector<std::shared_ptr<UnifiedRecord>> records = { fileUri, plainText, html };
618 
619     UnifiedData data1;
620     data1.SetRecords(records);
621 
622     std::shared_ptr<SystemDefinedAppItem> appItem =
623         std::make_shared<SystemDefinedAppItem>(UDType::SYSTEM_DEFINED_APP_ITEM, "OTHER param");
624     appItem->SetAppId("com.demo");
625     std::shared_ptr<ApplicationDefinedRecord> defineRecord =
626         std::make_shared<ApplicationDefinedRecord>(UDType::APPLICATION_DEFINED_RECORD, "OTHER param");
627     std::vector<uint8_t> u8Vector = { 1, 2, 3, 4 };
628     defineRecord->SetRawData(u8Vector);
629     std::shared_ptr<UnifiedRecord> fileRecord = std::make_shared<File>(UDType::FILE, "this is a oriUri");
630 
631     std::vector<std::shared_ptr<UnifiedRecord>> records2 = { appItem, defineRecord, fileRecord };
632 
633     UnifiedData data2;
634     data2.SetRecords(records2);
635 
636     std::vector<UnifiedData> datas = { data1, data2 };
637 
638     std::string dataFile = "demo1";
639     std::vector<uint8_t> dataBytes;
640     auto tlvObject = TLVObject(dataBytes);
641 
642     std::FILE *file = fopen(dataFile.c_str(), "w+");
643     tlvObject.SetFile(file);
644     UdmfConversion::InitValueObject(datas);
645     EXPECT_TRUE(TLVUtil::Writing(datas, tlvObject, TAG::TAG_UNIFIED_DATA));
646 
647     tlvObject.ResetCursor();
648     std::vector<UnifiedData> datasResult;
649 
650     EXPECT_TRUE(TLVUtil::ReadTlv(datasResult, tlvObject, TAG::TAG_UNIFIED_DATA));
651     EXPECT_EQ(2, datasResult.size());
652     UdmfConversion::ConvertRecordToSubclass(datasResult);
653 
654     auto recordsResult = datasResult[0].GetRecords();
655     EXPECT_EQ(3, recordsResult.size());
656 
657     auto fileUriResult = recordsResult[0];
658     EXPECT_EQ(UDType::FILE_URI, fileUriResult->GetType());
659     auto fileUriValue = fileUriResult->GetValue();
660     EXPECT_TRUE(std::holds_alternative<std::shared_ptr<Object>>(fileUriValue));
661     auto fileUriObj = std::get<std::shared_ptr<Object>>(fileUriValue);
662     EXPECT_EQ("File Uri", std::get<std::string>(fileUriObj->value_["fileUri"]));
663     EXPECT_EQ("File Type", std::get<std::string>(fileUriObj->value_["fileType"]));
664 
665     auto plainTextResult = recordsResult[1];
666     EXPECT_EQ(UDType::PLAIN_TEXT, plainTextResult->GetType());
667     auto plainTextSubclass = std::static_pointer_cast<PlainText>(plainTextResult);
668     EXPECT_EQ("this is a content", plainTextSubclass->GetContent());
669     auto plainTextValue = plainTextSubclass->GetValue();
670     EXPECT_TRUE(std::holds_alternative<std::string>(plainTextValue));
671 
672     auto htmlResult = recordsResult[2];
673     EXPECT_EQ(UDType::HTML, htmlResult->GetType());
674     auto htmlSubclass = std::static_pointer_cast<Html>(htmlResult);
675     EXPECT_EQ("this is a HTML content", htmlSubclass->GetHtmlContent());
676     auto htmlValue = htmlSubclass->GetValue();
677     EXPECT_TRUE(std::holds_alternative<std::string>(htmlValue));
678 
679     auto recordsResult2 = datasResult[1].GetRecords();
680     EXPECT_EQ(3, recordsResult2.size());
681     auto appItemResult = recordsResult2[0];
682     EXPECT_EQ(UDType::SYSTEM_DEFINED_APP_ITEM, appItemResult->GetType());
683     auto appItemSubclass = std::static_pointer_cast<SystemDefinedAppItem>(appItemResult);
684     EXPECT_EQ("com.demo", appItemSubclass->GetAppId());
685     auto appItemValue = appItemSubclass->GetValue();
686     EXPECT_TRUE(std::holds_alternative<std::string>(appItemValue));
687 
688     auto defineRecordResult = recordsResult2[1];
689     EXPECT_EQ(UDType::APPLICATION_DEFINED_RECORD, defineRecordResult->GetType());
690     auto adefineRecordSubclass = std::static_pointer_cast<ApplicationDefinedRecord>(defineRecordResult);
691     auto u8VectorResult = adefineRecordSubclass->GetRawData();
692     EXPECT_EQ(4, u8VectorResult.size());
693     auto adefineRecordValue = adefineRecordSubclass->GetValue();
694     EXPECT_TRUE(std::holds_alternative<std::string>(adefineRecordValue));
695 
696     auto fileResult = recordsResult2[2];
697     EXPECT_EQ(UDType::FILE, fileResult->GetType());
698     auto fileSubclass = std::static_pointer_cast<File>(fileResult);
699     EXPECT_EQ(16, fileSubclass->GetSize());
700     auto fileValue = fileSubclass->GetValue();
701     EXPECT_TRUE(std::holds_alternative<std::string>(fileValue));
702 
703     fclose(file);
704     LOG_INFO(UDMF_TEST, "WritingAndReadingFile_001 end.");
705 }
706 
707 /* *
708  * @tc.name: WritingAndReadingSummary_001
709  * @tc.desc: test Summary for Writing And Reading
710  * @tc.type: FUNC
711  */
712 HWTEST_F(TlvUtilTest, WritingAndReadingSummary_001, TestSize.Level1)
713 {
714     LOG_INFO(UDMF_TEST, "WritingAndReadingSummary_001 begin.");
715     std::map<std::string, ValueType> value;
716     value["fileType"] = "File Type";
717     value["fileUri"] = "File Uri";
718     std::shared_ptr<Object> obj = std::make_shared<Object>();
719     obj->value_ = value;
720     std::shared_ptr<UnifiedRecord> fileUri = std::make_shared<UnifiedRecord>(UDType::FILE_URI, obj);
721     std::shared_ptr<UnifiedRecord> plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, "this is a content");
722     std::shared_ptr<UnifiedRecord> html = std::make_shared<Html>(UDType::HTML, "this is a HTML content");
723     std::vector<std::shared_ptr<UnifiedRecord>> records = { fileUri, plainText, html };
724     UnifiedData data1;
725     data1.SetRecords(records);
726     Summary summary;
727     UnifiedDataHelper::GetSummary(data1, summary);
728     EXPECT_EQ(summary.summary.size(), records.size());
729 
730     std::vector<uint8_t> dataBytes;
731     auto tlvObject = TLVObject(dataBytes);
732     EXPECT_TRUE(TLVUtil::Writing(summary, tlvObject, TAG::TAG_SUMMARY));
733 
734     tlvObject.ResetCursor();
735     Summary summary2;
736     TLVUtil::ReadTlv(summary2, tlvObject, TAG::TAG_SUMMARY);
737     EXPECT_EQ(summary.totalSize, summary2.totalSize);
738     EXPECT_EQ(summary.summary.size(), summary2.summary.size());
739     for (const auto &[key, val] : summary.summary) {
740         ASSERT_TRUE(summary2.summary.find(key) != summary2.summary.end());
741         EXPECT_EQ(summary.summary[key], summary2.summary[key]);
742     }
743     LOG_INFO(UDMF_TEST, "WritingAndReadingSummary_001 end.");
744 }
745 
746 /* *
747  * @tc.name: WritingAndReadingVersion_001
748  * @tc.desc: test Version for Writing And Reading
749  * @tc.type: FUNC
750  */
751 HWTEST_F(TlvUtilTest, WritingAndReadingVersion_001, TestSize.Level1)
752 {
753     LOG_INFO(UDMF_TEST, "WritingAndReadingVersion_001 begin.");
754     std::shared_ptr<UnifiedRecord> plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, "this is a content");
755     std::shared_ptr<UnifiedRecord> html = std::make_shared<Html>(UDType::HTML, "this is a HTML content");
756     std::vector<std::shared_ptr<UnifiedRecord>> records = {plainText, html };
757     UnifiedData data1;
758     data1.SetRecords(records);
759     auto version = data1.GetSdkVersion();
760 
761     std::vector<uint8_t> dataBytes;
762     auto tlvObject = TLVObject(dataBytes);
763     std::vector<UnifiedData> datas = {data1};
764     EXPECT_TRUE(TLVUtil::Writing(datas, tlvObject, TAG::TAG_UNIFIED_DATA));
765 
766     tlvObject.ResetCursor();
767     std::vector<UnifiedData> datas2;
768     TLVUtil::ReadTlv(datas2, tlvObject, TAG::TAG_UNIFIED_DATA);
769     EXPECT_EQ(datas2.size(), 1);
770     EXPECT_EQ(datas2[0].GetSdkVersion(), version);
771     LOG_INFO(UDMF_TEST, "WritingAndReadingVersion_001 end.");
772 }
773 
774 /* *
775  * @tc.name: CountBufferSize_005
776  * @tc.desc: test UnifiedDataProperties element for countBufferSize
777  * @tc.type: FUNC
778  */
779 HWTEST_F(TlvUtilTest, CountBufferSize_005, TestSize.Level1)
780 {
781     LOG_INFO(UDMF_TEST, "CountBufferSize_005 begin.");
782 
783     std::vector<uint8_t> dataBytes;
784     auto tlvObject = TLVObject(dataBytes);
785 
786     OHOS::AAFwk::WantParams wantParams;
787     auto size = TLVUtil::CountBufferSize(wantParams, tlvObject);
788     EXPECT_EQ(tlvObject.GetTotal(), size);
789 
790     UnifiedDataProperties properties;
791     EXPECT_EQ(5 * sizeof(TLVHead) + sizeof(int64_t) + sizeof(int32_t) + 4,
792         TLVUtil::CountBufferSize(properties, tlvObject));
793 
794     LOG_INFO(UDMF_TEST, "CountBufferSize_005 end.");
795 }
796 
797 /* *
798  * @tc.name: WritingAndReading_006
799  * @tc.desc: test UnifiedDataProperties for Writing And Reading
800  * @tc.type: FUNC
801  */
802 HWTEST_F(TlvUtilTest, WritingAndReading_006, TestSize.Level1)
803 {
804     LOG_INFO(UDMF_TEST, "WritingAndReading_006 begin.");
805     OHOS::AAFwk::WantParams wantParams;
806     std::string idKey = "test006";
807     int32_t idValue = 123;
808     wantParams.SetParam(idKey, OHOS::AAFwk::Integer::Box(idValue));
809     UnifiedDataProperties properties;
810     properties.tag = "props";
811     properties.shareOptions = CROSS_APP;
812     properties.timestamp = 10;
813     properties.extras = wantParams;
814 
815     std::vector<uint8_t> dataBytes;
816     auto tlvObject = TLVObject(dataBytes);
817     auto result = TLVUtil::Writing(properties, tlvObject, TAG::TAG_UNIFIED_PROPERTIES);
818     EXPECT_TRUE(result);
819 
820     tlvObject.ResetCursor();
821     UnifiedDataProperties propertiesResult;
822     result = TLVUtil::ReadTlv(propertiesResult, tlvObject, TAG::TAG_UNIFIED_PROPERTIES);
823     EXPECT_TRUE(result);
824     EXPECT_EQ(properties.tag, propertiesResult.tag);
825     EXPECT_EQ(properties.shareOptions, propertiesResult.shareOptions);
826     EXPECT_EQ(properties.timestamp, propertiesResult.timestamp);
827     EXPECT_EQ(idValue, propertiesResult.extras.GetIntParam(idKey, 0));
828     LOG_INFO(UDMF_TEST, "WritingAndReading_006 end.");
829 }
830 
831 /* *
832  * @tc.name: WritingAndReading_007
833  * @tc.desc: test OHOS::AAFwk::WantParams for Writing And Reading
834  * @tc.type: FUNC
835  */
836 HWTEST_F(TlvUtilTest, WritingAndReading_007, TestSize.Level1)
837 {
838     LOG_INFO(UDMF_TEST, "WritingAndReading_007 begin.");
839     OHOS::AAFwk::WantParams wantParams;
840     std::string idKey = "test007";
841     int32_t idValue = 123456;
842     wantParams.SetParam(idKey, OHOS::AAFwk::Integer::Box(idValue));
843 
844     std::vector<uint8_t> dataBytes;
845     auto tlvObject = TLVObject(dataBytes);
846     auto result = TLVUtil::Writing(wantParams, tlvObject, TAG::TAG_PROPERTIES_EXTRAS);
847     EXPECT_TRUE(result);
848 
849     tlvObject.ResetCursor();
850     OHOS::AAFwk::WantParams wantParamsResult;
851     result = TLVUtil::ReadTlv(wantParamsResult, tlvObject, TAG::TAG_PROPERTIES_EXTRAS);
852     EXPECT_TRUE(result);
853     EXPECT_EQ(idValue, wantParamsResult.GetIntParam(idKey, 0));
854     LOG_INFO(UDMF_TEST, "WritingAndReading_007 end.");
855 }
856 
857 /* *
858  * @tc.name: Reading_001
859  * @tc.desc: Normal test of Reading
860  * @tc.type: FUNC
861  */
862 HWTEST_F(TlvUtilTest, Reading_001, TestSize.Level1)
863 {
864     std::nullptr_t output;
865     std::vector<std::uint8_t> buffer = { 1, 2 };
866     TLVObject data(buffer);
867     TLVHead head;
868     bool ret = TLVUtil::Reading(output, data, head);
869     EXPECT_EQ(ret, data.Read(output, head));
870 }
871 
872 /* *
873  * @tc.name: Reading_002
874  * @tc.desc: Abnormal test of Reading, data is invalid
875  * @tc.type: FUNC
876  */
877 HWTEST_F(TlvUtilTest, Reading_002, TestSize.Level1)
878 {
879     DataStatus output;
880     std::vector<std::uint8_t> buffer = { 1, 2 };
881     TLVObject data(buffer);
882     TLVHead head;
883     bool ret = TLVUtil::Reading(output, data, head);
884     EXPECT_FALSE(ret);
885 }
886 
887 /* *
888  * @tc.name: Reading_003
889  * @tc.desc: Abnormal test of Reading, buffer_ is nullptr
890  * @tc.type: FUNC
891  */
892 HWTEST_F(TlvUtilTest, Reading_003, TestSize.Level1)
893 {
894     Object output;
895     std::vector<std::uint8_t> buffer = { 1, 2 };
896     TLVObject data(buffer);
897     TLVHead head;
898     bool ret = TLVUtil::Reading(output, data, head);
899     EXPECT_FALSE(ret);
900 }
901 
902 /* *
903  * @tc.name: Reading_004
904  * @tc.desc: Abnormal test of Reading, data is invalid
905  * @tc.type: FUNC
906  */
907 HWTEST_F(TlvUtilTest, Reading_004, TestSize.Level1)
908 {
909     OHOS::AAFwk::WantParams output;
910     TLVObject data;
911     TLVHead head;
912     bool ret = TLVUtil::Reading(output, data, head);
913     EXPECT_FALSE(ret);
914 }
915 
916 /* *
917  * @tc.name: Reading_005
918  * @tc.desc: Test reading DataStatus with value below WORKING
919  * @tc.type: FUNC
920  */
921 HWTEST_F(TlvUtilTest, Reading_005, TestSize.Level1)
922 {
923     LOG_INFO(UDMF_TEST, "Reading_005 begin.");
924     int32_t invalidStatus = -1;
925     TLVHead head;
926     head.tag = static_cast<uint16_t>(TAG::TAG_DATA_STATUS);
927     head.len = sizeof(invalidStatus);
928 
929     std::vector<uint8_t> buffer;
930     buffer.resize(sizeof(head) + head.len);
931 
932     errno_t err = memcpy_s(buffer.data(), buffer.size(), &head, sizeof(head));
933     ASSERT_EQ(err, EOK);
934     err = memcpy_s(buffer.data() + sizeof(head), buffer.size() - sizeof(head),
935                    &invalidStatus, sizeof(invalidStatus));
936     ASSERT_EQ(err, EOK);
937     TLVObject data(buffer);
938     TLVHead readHead;
939     ASSERT_TRUE(data.ReadHead(readHead));
940 
941     DataStatus output;
942     EXPECT_FALSE(TLVUtil::Reading(output, data, readHead));
943     LOG_INFO(UDMF_TEST, "Reading_005 end.");
944 }
945 
946 /* *
947  * @tc.name: Reading_006
948  * @tc.desc: Test reading DataStatus with value at or above FADE
949  * @tc.type: FUNC
950  */
951 HWTEST_F(TlvUtilTest, Reading_006, TestSize.Level1)
952 {
953     LOG_INFO(UDMF_TEST, "Reading_006 begin.");
954     int32_t invalidStatus = 3;
955     TLVHead head;
956     head.tag = static_cast<uint16_t>(TAG::TAG_DATA_STATUS);
957     head.len = sizeof(invalidStatus);
958 
959     std::vector<uint8_t> buffer;
960     buffer.resize(sizeof(head) + head.len);
961     errno_t err = memcpy_s(buffer.data(), buffer.size(), &head, sizeof(head));
962     ASSERT_EQ(err, EOK);
963     err = memcpy_s(buffer.data() + sizeof(head), buffer.size() - sizeof(head),
964                    &invalidStatus, sizeof(invalidStatus));
965     ASSERT_EQ(err, EOK);
966     TLVObject data(buffer);
967     TLVHead readHead;
968     ASSERT_TRUE(data.ReadHead(readHead));
969 
970     DataStatus output;
971     EXPECT_FALSE(TLVUtil::Reading(output, data, readHead));
972     LOG_INFO(UDMF_TEST, "Reading_006 end.");
973 }
974 
975 /* *
976  * @tc.name: Reading_007
977  * @tc.desc: Test reading Object with incorrect inner tag
978  * @tc.type: FUNC
979  */
980 HWTEST_F(TlvUtilTest, Reading_007, TestSize.Level1)
981 {
982     LOG_INFO(UDMF_TEST, "Reading_007 begin.");
983     TLVHead outerHead;
984     outerHead.tag = static_cast<uint16_t>(TAG::TAG_OBJECT_VALUE);
985     outerHead.len = sizeof(TLVHead) + 4;
986 
987     TLVHead innerHead;
988     innerHead.tag = static_cast<uint16_t>(TAG::TAG_STRING);
989     innerHead.len = 4;
990 
991     const char* testData = "test";
992     std::vector<uint8_t> buffer;
993     buffer.resize(sizeof(outerHead) + sizeof(innerHead) + innerHead.len);
994 
995     errno_t err = memcpy_s(buffer.data(), buffer.size(), &outerHead, sizeof(outerHead));
996     ASSERT_EQ(err, EOK);
997     err = memcpy_s(buffer.data() + sizeof(outerHead), buffer.size() - sizeof(outerHead),
998                    &innerHead, sizeof(innerHead));
999     ASSERT_EQ(err, EOK);
1000     err = memcpy_s(buffer.data() + sizeof(outerHead) + sizeof(innerHead),
1001                    buffer.size() - sizeof(outerHead) - sizeof(innerHead),
1002                    testData, innerHead.len);
1003     ASSERT_EQ(err, EOK);
1004 
1005     TLVObject data(buffer);
1006     TLVHead readOuterHead;
1007     ASSERT_TRUE(data.ReadHead(readOuterHead));
1008 
1009     Object output;
1010     bool result = TLVUtil::Reading(output, data, readOuterHead);
1011     EXPECT_FALSE(result);
1012     LOG_INFO(UDMF_TEST, "Reading_007 end.");
1013 }
1014 
1015 /* *
1016  * @tc.name: Writing_001
1017  * @tc.desc: Abnormal test of Writing, input.tag is invalid
1018  * @tc.type: FUNC
1019  */
1020 HWTEST_F(TlvUtilTest, Writing_001, TestSize.Level1)
1021 {
1022     UnifiedDataProperties input;
1023     std::vector<std::uint8_t> buffer = { 1, 2 };
1024     TLVObject data(buffer);
1025     TAG tag = TAG::TAG_NULL;
1026     input.tag = "test";
1027     bool ret = TLVUtil::Writing(input, data, tag);
1028     EXPECT_FALSE(ret);
1029 }
1030 
1031 /* *
1032  * @tc.name: Writing_002
1033  * @tc.desc: Abnormal test of Writing, input.timestamp is invalid
1034  * @tc.type: FUNC
1035  */
1036 HWTEST_F(TlvUtilTest, Writing_002, TestSize.Level1)
1037 {
1038     UnifiedDataProperties input;
1039     std::vector<std::uint8_t> buffer = { 1, 2 };
1040     TLVObject data(buffer);
1041     std::string dataFile = "demo1";
1042     std::vector<uint8_t> dataBytes;
1043     auto tlvObject = TLVObject(dataBytes);
1044     std::FILE *file = fopen(dataFile.c_str(), "w+");
1045     tlvObject.SetFile(file);
1046     TAG tag = TAG::TAG_NULL;
1047     input.tag = "test";
1048     input.timestamp = 0;
1049     bool ret = TLVUtil::Writing(input, data, tag);
1050     EXPECT_FALSE(ret);
1051     fclose(file);
1052 }
1053 
1054 /* *
1055  * @tc.name: Writing_003
1056  * @tc.desc: Abnormal test of Writing input is invalid
1057  * @tc.type: FUNC
1058  */
1059 HWTEST_F(TlvUtilTest, Writing_003, TestSize.Level1)
1060 {
1061     Privilege input;
1062     std::vector<std::uint8_t> buffer = { 1, 2 };
1063     TLVObject data(buffer);
1064     TAG tag = TAG::TAG_NULL;
1065     bool ret = TLVUtil::Writing(input, data, tag);
1066     EXPECT_FALSE(ret);
1067 }
1068 
1069 /* *
1070  * @tc.name: CountBufferSize_006
1071  * @tc.desc: Abnormal test of CountBufferSize, input is nullptr
1072  * @tc.type: FUNC
1073  */
1074 HWTEST_F(TlvUtilTest, CountBufferSize_006, TestSize.Level1)
1075 {
1076     std::shared_ptr<std::map<std::string, ValueType>> input = nullptr;
1077     std::vector<std::uint8_t> buffer = { 1, 2 };
1078     TLVObject data(buffer);
1079     size_t ret = TLVUtil::CountBufferSize(input, data);
1080     EXPECT_EQ(ret, data.CountHead());
1081 }
1082 
1083 /* *
1084  * @tc.name: WritingSet001
1085  * @tc.desc: Normal test of Writing Set
1086  * @tc.type: FUNC
1087  */
1088 HWTEST_F(TlvUtilTest, WritingSet001, TestSize.Level1) {
1089     LOG_INFO(UDMF_TEST, "WritingSet001 begin.");
1090     std::set<std::string> data = {"typeA", "typeB", "typeC"};
1091 
1092     std::vector<uint8_t> dataBytes;
1093     auto tlvObject = TLVObject(dataBytes);
1094     auto result = TLVUtil::Writing(data, tlvObject, TAG::TAG_SET_TYPES);
1095     EXPECT_TRUE(result);
1096 
1097     tlvObject.ResetCursor();
1098     std::set<std::string> dataResult;
1099     result = TLVUtil::ReadTlv(dataResult, tlvObject, TAG::TAG_SET_TYPES);
1100     EXPECT_TRUE(result);
1101     ASSERT_EQ(data.size(), dataResult.size());
1102     for (auto &item : data) {
1103         EXPECT_TRUE(dataResult.find(item) != dataResult.end());
1104     }
1105     LOG_INFO(UDMF_TEST, "WritingSet001 end.");
1106 }
1107 
1108 /* *
1109  * @tc.name: WritingDataLoadInfo001
1110  * @tc.desc: Normal test of Writing DataLoadInfo
1111  * @tc.type: FUNC
1112  */
1113 HWTEST_F(TlvUtilTest, WritingDataLoadInfo001, TestSize.Level1) {
1114     LOG_INFO(UDMF_TEST, "WritingDataLoadInfo001 begin.");
1115     DataLoadInfo normalData;
1116     normalData.sequenceKey = "seq_2023";
1117     normalData.types = {"typeA", "typeB", "typeC"};
1118     normalData.recordCount = 1000;
1119 
1120     std::vector<uint8_t> dataBytes;
1121     auto tlvObject = TLVObject(dataBytes);
1122     auto result = TLVUtil::Writing(normalData, tlvObject, TAG::TAG_DATA_LOAD_INFO);
1123     EXPECT_TRUE(result);
1124 
1125     tlvObject.ResetCursor();
1126     DataLoadInfo normalDataResult;
1127     result = TLVUtil::ReadTlv(normalDataResult, tlvObject, TAG::TAG_DATA_LOAD_INFO);
1128     EXPECT_TRUE(result);
1129     EXPECT_EQ(normalData.sequenceKey, normalDataResult.sequenceKey);
1130     EXPECT_EQ(normalData.recordCount, normalDataResult.recordCount);
1131     ASSERT_EQ(normalData.types.size(), normalDataResult.types.size());
1132     for (auto &item : normalData.types) {
1133         EXPECT_TRUE(normalDataResult.types.find(item) != normalDataResult.types.end());
1134     }
1135     LOG_INFO(UDMF_TEST, "WritingDataLoadInfo001 end.");
1136 }
1137 
1138 /* *
1139  * @tc.name: WritingDataLoadInfo002
1140  * @tc.desc: Normal test of Writing boundary DataLoadInfo
1141  * @tc.type: FUNC
1142  */
1143 HWTEST_F(TlvUtilTest, WritingDataLoadInfo002, TestSize.Level1) {
1144     DataLoadInfo boundaryData;
1145     boundaryData.sequenceKey = "";
1146     boundaryData.types = {};
1147     boundaryData.recordCount = 0;
1148 
1149     std::vector<uint8_t> dataBytes;
1150     auto tlvObject = TLVObject(dataBytes);
1151     auto result = TLVUtil::Writing(boundaryData, tlvObject, TAG::TAG_DATA_LOAD_INFO);
1152     EXPECT_TRUE(result);
1153 
1154     tlvObject.ResetCursor();
1155     DataLoadInfo boundaryDataResult;
1156     result = TLVUtil::ReadTlv(boundaryDataResult, tlvObject, TAG::TAG_DATA_LOAD_INFO);
1157     EXPECT_TRUE(result);
1158     EXPECT_EQ(boundaryData.sequenceKey, boundaryDataResult.sequenceKey);
1159     EXPECT_EQ(boundaryData.recordCount, boundaryDataResult.recordCount);
1160     ASSERT_EQ(boundaryData.types.size(), boundaryDataResult.types.size());
1161     for (auto &item : boundaryData.types) {
1162         EXPECT_TRUE(boundaryDataResult.types.find(item) != boundaryDataResult.types.end());
1163     }
1164     LOG_INFO(UDMF_TEST, "WritingDataLoadInfo002 end.");
1165 }
1166 
1167 /* *
1168  * @tc.name: Reading_008
1169  * @tc.desc: test Reading fun
1170  * @tc.type: FUNC
1171  */
1172 HWTEST_F(TlvUtilTest, Reading_008, TestSize.Level1)
1173 {
1174     LOG_INFO(UDMF_TEST, "Reading_008 begin.");
1175     UnifiedKey uKey;
1176     UnifiedData uData;
1177     UnifiedDataProperties uProperties;
1178     UnifiedRecord uRecord;
1179     Runtime rTime;
1180     Privilege privilege;
1181     UriInfo uInfo;
1182     Summary summary;
1183     DataLoadInfo loadInfo;
1184     std::vector<std::uint8_t> buffer = { 1, 2 };
1185     TLVObject data(buffer);
1186     TLVHead head;
1187     head.len = data.GetTotal() - data.GetCursor() + 1;
1188     auto result = TLVUtil::Reading(uKey, data, head);
1189     EXPECT_FALSE(result);
1190     result = TLVUtil::Reading(uData, data, head);
1191     EXPECT_FALSE(result);
1192     result = TLVUtil::Reading(uProperties, data, head);
1193     EXPECT_FALSE(result);
1194     result = TLVUtil::Reading(uRecord, data, head);
1195     EXPECT_FALSE(result);
1196     result = TLVUtil::Reading(rTime, data, head);
1197     EXPECT_FALSE(result);
1198     result = TLVUtil::Reading(privilege, data, head);
1199     EXPECT_FALSE(result);
1200     result = TLVUtil::Reading(uInfo, data, head);
1201     EXPECT_FALSE(result);
1202     result = TLVUtil::Reading(summary, data, head);
1203     EXPECT_FALSE(result);
1204     result = TLVUtil::Reading(loadInfo, data, head);
1205     EXPECT_FALSE(result);
1206     LOG_INFO(UDMF_TEST, "Reading_008 end.");
1207 }
1208 
1209 /* *
1210  * @tc.name: Reading_009
1211  * @tc.desc: test Reading fun
1212  * @tc.type: FUNC
1213  */
1214 HWTEST_F(TlvUtilTest, Reading_009, TestSize.Level1)
1215 {
1216     LOG_INFO(UDMF_TEST, "Reading_009 begin.");
1217     UnifiedKey uKey;
1218     UnifiedData uData;
1219     UnifiedDataProperties uProperties;
1220     UnifiedRecord uRecord;
1221     Runtime rTime;
1222     Privilege privilege;
1223     UriInfo uInfo;
1224     Summary summary;
1225     DataLoadInfo loadInfo;
1226     std::vector<std::uint8_t> buffer = { 1, 2 };
1227     TLVObject data(buffer);
1228     TLVHead head;
1229     head.len = data.GetTotal() - data.GetCursor() - 1;
1230     auto result = TLVUtil::Reading(uKey, data, head);
1231     EXPECT_FALSE(result);
1232     result = TLVUtil::Reading(uData, data, head);
1233     EXPECT_FALSE(result);
1234     result = TLVUtil::Reading(uProperties, data, head);
1235     EXPECT_FALSE(result);
1236     result = TLVUtil::Reading(uRecord, data, head);
1237     EXPECT_FALSE(result);
1238     result = TLVUtil::Reading(rTime, data, head);
1239     EXPECT_FALSE(result);
1240     result = TLVUtil::Reading(privilege, data, head);
1241     EXPECT_FALSE(result);
1242     result = TLVUtil::Reading(uInfo, data, head);
1243     EXPECT_FALSE(result);
1244     result = TLVUtil::Reading(summary, data, head);
1245     EXPECT_FALSE(result);
1246     result = TLVUtil::Reading(loadInfo, data, head);
1247     EXPECT_FALSE(result);
1248     LOG_INFO(UDMF_TEST, "Reading_009 end.");
1249 }
1250 }
1251