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 "system_defined_appitem.h"
27 #include "application_defined_record.h"
28 #include "file.h"
29 #include "system_defined_form.h"
30 #include "system_defined_pixelmap.h"
31 #include "system_defined_record.h"
32 #include "udmf_conversion.h"
33 #include "unified_meta.h"
34 #include "unified_record.h"
35 #include "unified_types.h"
36 
37 using namespace testing::ext;
38 using namespace OHOS::UDMF;
39 using namespace OHOS;
40 
41 namespace OHOS::Test {
42 class TlvUtilTest : public testing::Test {
43 public:
44     static void SetUpTestCase(void);
45 
46     static void TearDownTestCase(void);
47 
48     void SetUp();
49 
50     void TearDown();
51 };
52 
SetUpTestCase(void)53 void TlvUtilTest::SetUpTestCase(void) {}
TearDownTestCase(void)54 void TlvUtilTest::TearDownTestCase(void) {}
SetUp(void)55 void TlvUtilTest::SetUp(void) {}
TearDown(void)56 void TlvUtilTest::TearDown(void) {}
57 
58 /* *
59  * @tc.name: CountBufferSize_001
60  * @tc.desc: test fundamental for countBufferSize
61  * @tc.type: FUNC
62  */
63 HWTEST_F(TlvUtilTest, CountBufferSize_001, TestSize.Level1)
64 {
65     LOG_INFO(UDMF_TEST, "CountBufferSize_001 begin.");
66     std::vector<uint8_t> dataBytes;
67     auto tlvObject = TLVObject(dataBytes);
68     uint8_t num1 = 1;
69     EXPECT_EQ(sizeof(TLVHead) + sizeof(num1), TLVUtil::CountBufferSize(num1, tlvObject)); // 7
70     uint16_t num2 = 1;
71     EXPECT_EQ(sizeof(TLVHead) + sizeof(num2), TLVUtil::CountBufferSize(num2, tlvObject)); // 8
72     uint32_t num3 = 1;
73     EXPECT_EQ(sizeof(TLVHead) + sizeof(num3), TLVUtil::CountBufferSize(num3, tlvObject)); // 10
74     int16_t num4 = 1;
75     EXPECT_EQ(sizeof(TLVHead) + sizeof(num4), TLVUtil::CountBufferSize(num4, tlvObject)); // 8
76     int32_t num5 = 1;
77     EXPECT_EQ(sizeof(TLVHead) + sizeof(num5), TLVUtil::CountBufferSize(num5, tlvObject)); // 10
78     bool boolean = true;
79     EXPECT_EQ(sizeof(TLVHead) + sizeof(boolean), TLVUtil::CountBufferSize(boolean, tlvObject)); // 7
80     double doubleNum = 1;
81     EXPECT_EQ(sizeof(TLVHead) + sizeof(doubleNum), TLVUtil::CountBufferSize(doubleNum, tlvObject)); // 14
82     EXPECT_EQ(sizeof(TLVHead), TLVUtil::CountBufferSize(std::nullptr_t(), tlvObject));              // 6
83     std::monostate monostate;
84     EXPECT_EQ(sizeof(TLVHead), TLVUtil::CountBufferSize(monostate, tlvObject)); // 6
85     std::string str = "abc";
86     EXPECT_EQ(sizeof(TLVHead) + str.size(), TLVUtil::CountBufferSize(str, tlvObject)); // 9
87     UDType type = XML;
88     EXPECT_EQ(sizeof(TLVHead) + sizeof(type), TLVUtil::CountBufferSize(type, tlvObject)); // 10
89     DataStatus status = HISTORY;
90     EXPECT_EQ(sizeof(TLVHead) + sizeof(status), TLVUtil::CountBufferSize(status, tlvObject)); // 10
91     std::vector<uint8_t> u8Vector = { 1, 1, 1 };
92     EXPECT_EQ(sizeof(TLVHead) + u8Vector.size(), TLVUtil::CountBufferSize(u8Vector, tlvObject)); // 9
93     std::shared_ptr<uint8_t> ptr;
94     EXPECT_EQ(sizeof(TLVHead), TLVUtil::CountBufferSize(ptr, tlvObject)); // 6
95     ptr = std::make_shared<uint8_t>(1);
96     EXPECT_EQ(sizeof(TLVHead) + 1, TLVUtil::CountBufferSize(ptr, tlvObject)); // 7
97     LOG_INFO(UDMF_TEST, "CountBufferSize_001 end.");
98 }
99 
100 /* *
101  * @tc.name: CountBufferSize_002
102  * @tc.desc: test STL for countBufferSize
103  * @tc.type: FUNC
104  */
105 HWTEST_F(TlvUtilTest, CountBufferSize_002, TestSize.Level1)
106 {
107     LOG_INFO(UDMF_TEST, "CountBufferSize_002 begin.");
108     std::vector<uint8_t> dataBytes;
109     auto tlvObject = TLVObject(dataBytes);
110     Privilege privilege1;
111     privilege1.readPermission = "111";
112     Privilege privilege2;
113     privilege2.readPermission = "111";
114     privilege2.writePermission = "xx";
115     std::vector<Privilege> privilegeVector{ privilege1, privilege2 };
116     EXPECT_EQ(10 * sizeof(TLVHead) + 2 * sizeof(uint32_t) + sizeof(size_t) + 8,
117         TLVUtil::CountBufferSize(privilegeVector, tlvObject)); // 80
118 
119     Object object;
120     std::map<std::string, ValueType> map;
121     map["keyString"] = "value";
122     double key = 12;
123     map["keyNum"] = key;
124     object.value_ = map;
125     EXPECT_EQ(12 * sizeof(TLVHead) + 36, TLVUtil::CountBufferSize(object, tlvObject)); // 108
126     LOG_INFO(UDMF_TEST, "CountBufferSize_002 end.");
127 }
128 
129 /* *
130  * @tc.name: CountBufferSize_003
131  * @tc.desc: test udmf for countBufferSize
132  * @tc.type: FUNC
133  */
134 HWTEST_F(TlvUtilTest, CountBufferSize_003, TestSize.Level1)
135 {
136     LOG_INFO(UDMF_TEST, "CountBufferSize_003 begin.");
137     std::vector<uint8_t> dataBytes;
138     auto tlvObject = TLVObject(dataBytes);
139 
140     std::shared_ptr<Object> object = std::make_shared<Object>();
141     std::map<std::string, ValueType> map;
142     map["uniformDataType"] = UtdUtils::GetUtdIdFromUtdEnum(UDType::PLAIN_TEXT);
143     map["textContent"] = "content";
144     map["abstract"] = "abstract";
145     object->value_ = map;
146     std::shared_ptr<UnifiedRecord> record = std::make_shared<PlainText>(PLAIN_TEXT, object);
147 
148     std::vector<std::shared_ptr<UnifiedRecord>> vector = { record };
149     UnifiedData data;
150     data.SetRecords(vector);
151     std::vector<UnifiedData> unifiedData = { data };
152     auto size = TLVUtil::CountBufferSize(unifiedData, tlvObject);
153     EXPECT_EQ(tlvObject.GetTotal(), size); // 269
154     LOG_INFO(UDMF_TEST, "CountBufferSize_003 end.");
155 }
156 
157 /* *
158  * @tc.name: CountBufferSize_004
159  * @tc.desc: test other for countBufferSize
160  * @tc.type: FUNC
161  */
162 HWTEST_F(TlvUtilTest, CountBufferSize_004, TestSize.Level1)
163 {
164     LOG_INFO(UDMF_TEST, "CountBufferSize_004 begin.");
165     std::vector<uint8_t> dataBytes;
166     auto tlvObject = TLVObject(dataBytes);
167 
168     UnifiedKey key;
169     key.key = "123456";
170     key.intention = "DRAG";
171     key.bundleName = "com.xxx";
172     EXPECT_EQ(5 * sizeof(TLVHead) + 17, TLVUtil::CountBufferSize(key, tlvObject));
173 
174     Privilege privilege;
175     EXPECT_EQ(4 * sizeof(TLVHead) + sizeof(int32_t), TLVUtil::CountBufferSize(privilege, tlvObject));
176 
177     Runtime runtime;
178     EXPECT_EQ(19 * sizeof(TLVHead) + sizeof(bool) + sizeof(size_t) + 2 * sizeof(int64_t) + 2 * sizeof(int32_t) +
179         2 * sizeof(uint32_t),
180         TLVUtil::CountBufferSize(runtime, tlvObject));
181     LOG_INFO(UDMF_TEST, "CountBufferSize_004 end.");
182 }
183 
184 /* *
185  * @tc.name: WritingAndReading_001
186  * @tc.desc: test fundamental for Writing And Reading
187  * @tc.type: FUNC
188  */
189 HWTEST_F(TlvUtilTest, WritingAndReading_001, TestSize.Level1)
190 {
191     LOG_INFO(UDMF_TEST, "WritingAndReading_001 begin.");
192     std::vector<uint8_t> dataBytes;
193     auto tlvObject = TLVObject(dataBytes);
194     uint16_t num1 = 1;
195     auto result = TLVUtil::Writing(num1, tlvObject, TAG::TAG_UINT16);
196     int8_t num2 = 2;
197     result = TLVUtil::Writing(num2, tlvObject, TAG::TAG_INT8) && result;
198     uint32_t num3 = 3;
199     result = TLVUtil::Writing(num3, tlvObject, TAG::TAG_UINT32) && result;
200     int16_t num4 = 4;
201     result = TLVUtil::Writing(num4, tlvObject, TAG::TAG_INT16) && result;
202     int32_t num5 = 5;
203     result = result = TLVUtil::Writing(num5, tlvObject, TAG::TAG_INT32) && result;
204     bool boolean = true;
205     result = TLVUtil::Writing(boolean, tlvObject, TAG::TAG_BOOL) && result;
206     result = TLVUtil::Writing(std::nullptr_t(), tlvObject, TAG::TAG_NULL);
207     std::monostate monostate;
208     result = TLVUtil::Writing(monostate, tlvObject, TAG::TAG_MONOSTATE) && result;
209     std::string str = "abc";
210     result = TLVUtil::Writing(str, tlvObject, TAG::TAG_STRING) && result;
211     UDType type = XML;
212     result = TLVUtil::Writing(type, tlvObject, TAG::TAG_UD_TYPE) && result;
213     DataStatus status = HISTORY;
214     result = TLVUtil::Writing(status, tlvObject, TAG::TAG_DATA_STATUS) && result;
215     std::vector<uint8_t> u8Vector = { 1, 2, 3 };
216     result = TLVUtil::Writing(u8Vector, tlvObject, TAG::TAG_UINT8) && result;
217     EXPECT_TRUE(result);
218 
219     uint16_t num1Result;
220     int8_t num2Result;
221     uint32_t num3Result;
222     int16_t num4Result;
223     int32_t num5Result;
224     bool booleanResult;
225     std::string strResult;
226     UDType typeResult;
227     DataStatus statusResult;
228     std::vector<uint8_t> u8VectorResult;
229 
230     tlvObject.ResetCursor();
231     TLVUtil::ReadTlv(statusResult, tlvObject, TAG::TAG_DATA_STATUS);
232     tlvObject.ResetCursor();
233     EXPECT_EQ(status, statusResult);
234 
235     tlvObject.ResetCursor();
236     TLVUtil::ReadTlv(typeResult, tlvObject, TAG::TAG_UD_TYPE);
237     EXPECT_EQ(type, typeResult);
238 
239     tlvObject.ResetCursor();
240     TLVUtil::ReadTlv(strResult, tlvObject, TAG::TAG_STRING);
241     EXPECT_EQ(str, strResult);
242 
243     tlvObject.ResetCursor();
244     TLVUtil::ReadTlv(booleanResult, tlvObject, TAG::TAG_BOOL);
245     EXPECT_EQ(boolean, booleanResult);
246 
247     tlvObject.ResetCursor();
248     TLVUtil::ReadTlv(num5Result, tlvObject, TAG::TAG_INT32);
249     EXPECT_EQ(num5, num5Result);
250 
251     tlvObject.ResetCursor();
252     TLVUtil::ReadTlv(num4Result, tlvObject, TAG::TAG_INT16);
253     EXPECT_EQ(num4, num4Result);
254 
255     tlvObject.ResetCursor();
256     TLVUtil::ReadTlv(num3Result, tlvObject, TAG::TAG_UINT32);
257     EXPECT_EQ(num3, num3Result);
258 
259     tlvObject.ResetCursor();
260     TLVUtil::ReadTlv(num2Result, tlvObject, TAG::TAG_INT8);
261     EXPECT_EQ(num2, num2Result);
262 
263     tlvObject.ResetCursor();
264     TLVUtil::ReadTlv(num1Result, tlvObject, TAG::TAG_UINT16);
265     EXPECT_EQ(num1, num1Result);
266 
267     tlvObject.ResetCursor();
268     TLVUtil::ReadTlv(u8VectorResult, tlvObject, TAG::TAG_UINT8);
269     for (int i = 0; i < 3; i++) {
270         EXPECT_EQ(u8Vector[i], u8VectorResult[i]);
271     }
272     LOG_INFO(UDMF_TEST, "WritingAndReading_001 end.");
273 }
274 
275 /* *
276  * @tc.name: WritingAndReading_002
277  * @tc.desc: test Runtime for Writing And Reading
278  * @tc.type: FUNC
279  */
280 HWTEST_F(TlvUtilTest, WritingAndReading_002, TestSize.Level1)
281 {
282     LOG_INFO(UDMF_TEST, "WritingAndReading_002 begin.");
283     UnifiedKey key;
284     key.key = "123456";
285     Privilege privilege;
286     privilege.readPermission = "read";
287     privilege.tokenId = 333;
288     Privilege privilege2;
289     privilege2.writePermission = "read";
290     privilege2.tokenId = 444;
291     Runtime runtime;
292     runtime.dataStatus = DELETED;
293     runtime.key = key;
294     runtime.privileges.push_back(privilege);
295     runtime.privileges.push_back(privilege2);
296     runtime.createTime = 1;
297     runtime.dataVersion = 3;
298     runtime.createPackage = "package";
299     runtime.isPrivate = true;
300 
301     std::vector<uint8_t> dataBytes;
302     auto tlvObject = TLVObject(dataBytes);
303     EXPECT_TRUE(TLVUtil::Writing(runtime, tlvObject, TAG::TAG_RUNTIME));
304 
305     tlvObject.ResetCursor();
306     Runtime runtimeResult;
307     EXPECT_TRUE(TLVUtil::ReadTlv(runtimeResult, tlvObject, TAG::TAG_RUNTIME));
308     EXPECT_EQ(runtime.key.key, runtimeResult.key.key);
309     EXPECT_EQ(runtime.key.key, runtimeResult.key.key);
310     EXPECT_EQ(runtime.dataStatus, runtimeResult.dataStatus);
311     EXPECT_EQ(runtime.createTime, runtimeResult.createTime);
312     EXPECT_EQ(runtime.dataVersion, runtimeResult.dataVersion);
313     EXPECT_EQ(runtime.createPackage, runtimeResult.createPackage);
314     EXPECT_EQ(runtime.isPrivate, runtimeResult.isPrivate);
315     EXPECT_EQ(runtime.privileges[0].readPermission, runtimeResult.privileges[0].readPermission);
316     EXPECT_EQ(runtime.privileges[0].tokenId, runtimeResult.privileges[0].tokenId);
317     EXPECT_EQ(runtime.privileges[1].writePermission, runtimeResult.privileges[1].writePermission);
318     EXPECT_EQ(runtime.privileges[1].tokenId, runtimeResult.privileges[1].tokenId);
319 
320     LOG_INFO(UDMF_TEST, "WritingAndReading_002 end.");
321 }
322 
323 /* *
324  * @tc.name: WritingAndReading_003
325  * @tc.desc: test UnifiedData for Writing And Reading
326  * @tc.type: FUNC
327  */
328 HWTEST_F(TlvUtilTest, WritingAndReading_003, TestSize.Level1)
329 {
330     LOG_INFO(UDMF_TEST, "WritingAndReading_003 begin.");
331 
332     std::map<std::string, ValueType> value;
333     value["fileType"] = "File Type";
334     value["fileUri"] = "File Uri";
335     std::shared_ptr<Object> obj = std::make_shared<Object>();
336     obj->value_ = value;
337     std::shared_ptr<UnifiedRecord> fileUri = std::make_shared<UnifiedRecord>(UDType::FILE_URI, obj);
338 
339     std::shared_ptr<UnifiedRecord> plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, "this is a content");
340     std::shared_ptr<UnifiedRecord> html = std::make_shared<Html>(UDType::HTML, "this is a HTML content");
341 
342     std::vector<std::shared_ptr<UnifiedRecord>> records = { fileUri, plainText, html };
343 
344     UnifiedData data1;
345     data1.SetRecords(records);
346 
347     std::shared_ptr<SystemDefinedAppItem> appItem =
348         std::make_shared<SystemDefinedAppItem>(UDType::SYSTEM_DEFINED_APP_ITEM, "OTHER param");
349     appItem->SetAppId("com.demo");
350     std::shared_ptr<ApplicationDefinedRecord> defineRecord =
351         std::make_shared<ApplicationDefinedRecord>(UDType::APPLICATION_DEFINED_RECORD, "OTHER param");
352     std::vector<uint8_t> u8Vector = { 1, 2, 3, 4 };
353     defineRecord->SetRawData(u8Vector);
354     std::shared_ptr<UnifiedRecord> file = std::make_shared<File>(UDType::FILE, "this is a oriUri");
355 
356     std::vector<std::shared_ptr<UnifiedRecord>> records2 = { appItem, defineRecord, file };
357 
358     UnifiedData data2;
359     data2.SetRecords(records2);
360 
361     std::vector<UnifiedData> datas = { data1, data2 };
362 
363     std::vector<uint8_t> dataBytes;
364     auto tlvObject = TLVObject(dataBytes);
365 
366     UdmfConversion::InitValueObject(datas);
367     EXPECT_TRUE(TLVUtil::Writing(datas, tlvObject, TAG::TAG_UNIFIED_DATA));
368 
369     tlvObject.ResetCursor();
370     std::vector<UnifiedData> datasResult;
371 
372     EXPECT_TRUE(TLVUtil::ReadTlv(datasResult, tlvObject, TAG::TAG_UNIFIED_DATA));
373     EXPECT_EQ(2, datasResult.size());
374     UdmfConversion::ConvertRecordToSubclass(datasResult);
375 
376     auto recordsResult = datasResult[0].GetRecords();
377     EXPECT_EQ(3, recordsResult.size());
378 
379     auto fileUriResult = recordsResult[0];
380     EXPECT_EQ(UDType::FILE_URI, fileUriResult->GetType());
381     auto fileUriValue = fileUriResult->GetValue();
382     EXPECT_TRUE(std::holds_alternative<std::shared_ptr<Object>>(fileUriValue));
383     auto fileUriObj = std::get<std::shared_ptr<Object>>(fileUriValue);
384     EXPECT_EQ("File Uri", std::get<std::string>(fileUriObj->value_["fileUri"]));
385     EXPECT_EQ("File Type", std::get<std::string>(fileUriObj->value_["fileType"]));
386 
387     auto plainTextResult = recordsResult[1];
388     EXPECT_EQ(UDType::PLAIN_TEXT, plainTextResult->GetType());
389     auto plainTextSubclass = std::static_pointer_cast<PlainText>(plainTextResult);
390     EXPECT_EQ("this is a content", plainTextSubclass->GetContent());
391     auto plainTextValue = plainTextSubclass->GetValue();
392     EXPECT_TRUE(std::holds_alternative<std::string>(plainTextValue));
393 
394     auto htmlResult = recordsResult[2];
395     EXPECT_EQ(UDType::HTML, htmlResult->GetType());
396     auto htmlSubclass = std::static_pointer_cast<Html>(htmlResult);
397     EXPECT_EQ("this is a HTML content", htmlSubclass->GetHtmlContent());
398     auto htmlValue = htmlSubclass->GetValue();
399     EXPECT_TRUE(std::holds_alternative<std::string>(htmlValue));
400 
401     auto recordsResult2 = datasResult[1].GetRecords();
402     EXPECT_EQ(3, recordsResult2.size());
403     auto appItemResult = recordsResult2[0];
404     EXPECT_EQ(UDType::SYSTEM_DEFINED_APP_ITEM, appItemResult->GetType());
405     auto appItemSubclass = std::static_pointer_cast<SystemDefinedAppItem>(appItemResult);
406     EXPECT_EQ("com.demo", appItemSubclass->GetAppId());
407     auto appItemValue = appItemSubclass->GetValue();
408     EXPECT_TRUE(std::holds_alternative<std::string>(appItemValue));
409 
410     auto defineRecordResult = recordsResult2[1];
411     EXPECT_EQ(UDType::APPLICATION_DEFINED_RECORD, defineRecordResult->GetType());
412     auto adefineRecordSubclass = std::static_pointer_cast<ApplicationDefinedRecord>(defineRecordResult);
413     auto u8VectorResult = adefineRecordSubclass->GetRawData();
414     EXPECT_EQ(4, u8VectorResult.size());
415     auto adefineRecordValue = adefineRecordSubclass->GetValue();
416     EXPECT_TRUE(std::holds_alternative<std::string>(adefineRecordValue));
417 
418     auto fileResult = recordsResult2[2];
419     EXPECT_EQ(UDType::FILE, fileResult->GetType());
420     auto fileSubclass = std::static_pointer_cast<File>(fileResult);
421     EXPECT_EQ(16, fileSubclass->GetSize());
422     auto fileValue = fileSubclass->GetValue();
423     EXPECT_TRUE(std::holds_alternative<std::string>(fileValue));
424 
425     LOG_INFO(UDMF_TEST, "WritingAndReading_003 end.");
426 }
427 
428 /* *
429  * @tc.name: WritingAndReading_004
430  * @tc.desc: test UnifiedData for Writing And Reading
431  * @tc.type: FUNC
432  */
433 HWTEST_F(TlvUtilTest, WritingAndReading_004, TestSize.Level1)
434 {
435     LOG_INFO(UDMF_TEST, "WritingAndReading_004 begin.");
436 
437     uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
438     OHOS::Media::InitializationOptions opts = { { 5, 7 },
439         Media::PixelFormat::ARGB_8888,
440         Media::PixelFormat::ARGB_8888 };
441     std::unique_ptr<OHOS::Media::PixelMap> pixelMap =
442         OHOS::Media::PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
443     std::shared_ptr<OHOS::Media::PixelMap> pixelMapIn = move(pixelMap);
444     std::map<std::string, ValueType> value;
445     value["pixelMap"] = pixelMapIn;
446     std::shared_ptr<Object> obj = std::make_shared<Object>();
447     obj->value_ = value;
448     std::shared_ptr<UnifiedRecord> pixelMapRecord =
449         std::make_shared<SystemDefinedPixelMap>(UDType::SYSTEM_DEFINED_PIXEL_MAP, obj);
450 
451     std::shared_ptr<SystemDefinedForm> form =
452         std::make_shared<SystemDefinedForm>(UDType::SYSTEM_DEFINED_FORM, "Other parm");
453     form->SetFormName("HAPPY DAY");
454 
455     UDDetails details;
456     details.emplace("name", "ZhangSan");
457     details.emplace("age", 30);
458     details.emplace("isFemal", true);
459     std::shared_ptr<SystemDefinedRecord> definedRecord =
460         std::make_shared<SystemDefinedRecord>(UDType::SYSTEM_DEFINED_RECORD, "Other parm");
461     definedRecord->SetDetails(details);
462     std::vector<std::shared_ptr<UnifiedRecord>> records = { pixelMapRecord, form, definedRecord };
463 
464     UnifiedData data;
465     data.SetRecords(records);
466 
467     std::vector<UnifiedData> datas = { data };
468 
469     std::vector<uint8_t> dataBytes;
470     auto tlvObject = TLVObject(dataBytes);
471 
472     UdmfConversion::InitValueObject(datas);
473     EXPECT_TRUE(TLVUtil::Writing(datas, tlvObject, TAG::TAG_UNIFIED_DATA));
474 
475     tlvObject.ResetCursor();
476     std::vector<UnifiedData> datasResult;
477 
478     EXPECT_TRUE(TLVUtil::ReadTlv(datasResult, tlvObject, TAG::TAG_UNIFIED_DATA));
479     EXPECT_EQ(1, datasResult.size());
480     UdmfConversion::ConvertRecordToSubclass(datasResult);
481 
482     auto recordsResult = datasResult[0].GetRecords();
483     EXPECT_EQ(3, recordsResult.size());
484 
485     auto pixelMapRecordResult = recordsResult[0];
486     EXPECT_EQ(UDType::SYSTEM_DEFINED_PIXEL_MAP, pixelMapRecordResult->GetType());
487     auto pixelMapValue = pixelMapRecordResult->GetValue();
488     EXPECT_TRUE(std::holds_alternative<std::shared_ptr<Object>>(pixelMapValue));
489     auto pixelMapObj = std::get<std::shared_ptr<Object>>(pixelMapValue);
490     EXPECT_TRUE(std::holds_alternative<std::shared_ptr<OHOS::Media::PixelMap>>(pixelMapObj->value_["pixelMap"]));
491     auto piexelMapResult = std::get<std::shared_ptr<OHOS::Media::PixelMap>>(pixelMapObj->value_["pixelMap"]);
492     EXPECT_EQ(7, piexelMapResult->GetHeight());
493 
494     auto formResult = recordsResult[1];
495     EXPECT_EQ(UDType::SYSTEM_DEFINED_FORM, formResult->GetType());
496     auto formSubclass = std::static_pointer_cast<SystemDefinedForm>(formResult);
497     EXPECT_EQ("HAPPY DAY", formSubclass->GetFormName());
498     auto formValue = formSubclass->GetValue();
499     EXPECT_TRUE(std::holds_alternative<std::string>(formValue));
500 
501     auto definedRecordResult = recordsResult[2];
502     EXPECT_EQ(UDType::SYSTEM_DEFINED_RECORD, definedRecordResult->GetType());
503     auto definedRecordSubclass = std::static_pointer_cast<SystemDefinedRecord>(definedRecordResult);
504     auto detailsRecord = definedRecordSubclass->GetDetails();
505     EXPECT_EQ("ZhangSan", std::get<std::string>(detailsRecord["name"]));
506     EXPECT_EQ(30, std::get<int32_t>(detailsRecord["age"]));
507     EXPECT_TRUE(std::get<bool>(detailsRecord["isFemal"]));
508     auto definedRecordValue = definedRecordSubclass->GetValue();
509     EXPECT_TRUE(std::holds_alternative<std::string>(definedRecordValue));
510 
511     LOG_INFO(UDMF_TEST, "WritingAndReading_004 end.");
512 }
513 
514 /* *
515  * @tc.name: WritingAndReading_005
516  * @tc.desc: test Want for Writing And Reading
517  * @tc.type: FUNC
518  */
519 HWTEST_F(TlvUtilTest, WritingAndReading_005, TestSize.Level1)
520 {
521     LOG_INFO(UDMF_TEST, "WritingAndReading_005 begin.");
522     std::shared_ptr<OHOS::AAFwk::Want> want = std::make_shared<OHOS::AAFwk::Want>();
523     std::string idKey = "id";
524     int32_t idValue = 123;
525     want->SetParam(idKey, idValue);
526     std::map<std::string, ValueType> value;
527     value["want"] = want;
528     std::shared_ptr<Object> obj = std::make_shared<Object>();
529     obj->value_ = value;
530 
531     std::vector<uint8_t> dataBytes;
532     auto tlvObject = TLVObject(dataBytes);
533 
534     EXPECT_TRUE(TLVUtil::Writing(obj, tlvObject, TAG::TAG_OBJECT_VALUE));
535     tlvObject.ResetCursor();
536     std::shared_ptr<Object> objResult = std::make_shared<Object>();
537     EXPECT_TRUE(TLVUtil::ReadTlv(objResult, tlvObject, TAG::TAG_OBJECT_VALUE));
538     auto valueResult = objResult->value_;
539     EXPECT_TRUE(std::holds_alternative<std::shared_ptr<OHOS::AAFwk::Want>>(valueResult["want"]));
540     auto wantResult = std::get<std::shared_ptr<OHOS::AAFwk::Want>>(valueResult["want"]);
541     EXPECT_EQ(idValue, wantResult->GetIntParam(idKey, 0));
542     LOG_INFO(UDMF_TEST, "WritingAndReading_005 end.");
543 }
544 
545 /* *
546  * @tc.name: WritingAndReadingFile_001
547  * @tc.desc: test Unified Data for Writing And Reading
548  * @tc.type: FUNC
549  */
550 HWTEST_F(TlvUtilTest, WritingAndReadingFile_001, TestSize.Level1)
551 {
552     LOG_INFO(UDMF_TEST, "WritingAndReadingFile_001 begin.");
553     std::map<std::string, ValueType> value;
554     value["fileType"] = "File Type";
555     value["fileUri"] = "File Uri";
556     std::shared_ptr<Object> obj = std::make_shared<Object>();
557     obj->value_ = value;
558     std::shared_ptr<UnifiedRecord> fileUri = std::make_shared<UnifiedRecord>(UDType::FILE_URI, obj);
559 
560     std::shared_ptr<UnifiedRecord> plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, "this is a content");
561     std::shared_ptr<UnifiedRecord> html = std::make_shared<Html>(UDType::HTML, "this is a HTML content");
562 
563     std::vector<std::shared_ptr<UnifiedRecord>> records = { fileUri, plainText, html };
564 
565     UnifiedData data1;
566     data1.SetRecords(records);
567 
568     std::shared_ptr<SystemDefinedAppItem> appItem =
569         std::make_shared<SystemDefinedAppItem>(UDType::SYSTEM_DEFINED_APP_ITEM, "OTHER param");
570     appItem->SetAppId("com.demo");
571     std::shared_ptr<ApplicationDefinedRecord> defineRecord =
572         std::make_shared<ApplicationDefinedRecord>(UDType::APPLICATION_DEFINED_RECORD, "OTHER param");
573     std::vector<uint8_t> u8Vector = { 1, 2, 3, 4 };
574     defineRecord->SetRawData(u8Vector);
575     std::shared_ptr<UnifiedRecord> fileRecord = std::make_shared<File>(UDType::FILE, "this is a oriUri");
576 
577     std::vector<std::shared_ptr<UnifiedRecord>> records2 = { appItem, defineRecord, fileRecord };
578 
579     UnifiedData data2;
580     data2.SetRecords(records2);
581 
582     std::vector<UnifiedData> datas = { data1, data2 };
583 
584     std::string dataFile = "demo1";
585     std::vector<uint8_t> dataBytes;
586     auto tlvObject = TLVObject(dataBytes);
587 
588     std::FILE *file = fopen(dataFile.c_str(), "w+");
589     tlvObject.SetFile(file);
590     UdmfConversion::InitValueObject(datas);
591     EXPECT_TRUE(TLVUtil::Writing(datas, tlvObject, TAG::TAG_UNIFIED_DATA));
592 
593     tlvObject.ResetCursor();
594     std::vector<UnifiedData> datasResult;
595 
596     EXPECT_TRUE(TLVUtil::ReadTlv(datasResult, tlvObject, TAG::TAG_UNIFIED_DATA));
597     EXPECT_EQ(2, datasResult.size());
598     UdmfConversion::ConvertRecordToSubclass(datasResult);
599 
600     auto recordsResult = datasResult[0].GetRecords();
601     EXPECT_EQ(3, recordsResult.size());
602 
603     auto fileUriResult = recordsResult[0];
604     EXPECT_EQ(UDType::FILE_URI, fileUriResult->GetType());
605     auto fileUriValue = fileUriResult->GetValue();
606     EXPECT_TRUE(std::holds_alternative<std::shared_ptr<Object>>(fileUriValue));
607     auto fileUriObj = std::get<std::shared_ptr<Object>>(fileUriValue);
608     EXPECT_EQ("File Uri", std::get<std::string>(fileUriObj->value_["fileUri"]));
609     EXPECT_EQ("File Type", std::get<std::string>(fileUriObj->value_["fileType"]));
610 
611     auto plainTextResult = recordsResult[1];
612     EXPECT_EQ(UDType::PLAIN_TEXT, plainTextResult->GetType());
613     auto plainTextSubclass = std::static_pointer_cast<PlainText>(plainTextResult);
614     EXPECT_EQ("this is a content", plainTextSubclass->GetContent());
615     auto plainTextValue = plainTextSubclass->GetValue();
616     EXPECT_TRUE(std::holds_alternative<std::string>(plainTextValue));
617 
618     auto htmlResult = recordsResult[2];
619     EXPECT_EQ(UDType::HTML, htmlResult->GetType());
620     auto htmlSubclass = std::static_pointer_cast<Html>(htmlResult);
621     EXPECT_EQ("this is a HTML content", htmlSubclass->GetHtmlContent());
622     auto htmlValue = htmlSubclass->GetValue();
623     EXPECT_TRUE(std::holds_alternative<std::string>(htmlValue));
624 
625     auto recordsResult2 = datasResult[1].GetRecords();
626     EXPECT_EQ(3, recordsResult2.size());
627     auto appItemResult = recordsResult2[0];
628     EXPECT_EQ(UDType::SYSTEM_DEFINED_APP_ITEM, appItemResult->GetType());
629     auto appItemSubclass = std::static_pointer_cast<SystemDefinedAppItem>(appItemResult);
630     EXPECT_EQ("com.demo", appItemSubclass->GetAppId());
631     auto appItemValue = appItemSubclass->GetValue();
632     EXPECT_TRUE(std::holds_alternative<std::string>(appItemValue));
633 
634     auto defineRecordResult = recordsResult2[1];
635     EXPECT_EQ(UDType::APPLICATION_DEFINED_RECORD, defineRecordResult->GetType());
636     auto adefineRecordSubclass = std::static_pointer_cast<ApplicationDefinedRecord>(defineRecordResult);
637     auto u8VectorResult = adefineRecordSubclass->GetRawData();
638     EXPECT_EQ(4, u8VectorResult.size());
639     auto adefineRecordValue = adefineRecordSubclass->GetValue();
640     EXPECT_TRUE(std::holds_alternative<std::string>(adefineRecordValue));
641 
642     auto fileResult = recordsResult2[2];
643     EXPECT_EQ(UDType::FILE, fileResult->GetType());
644     auto fileSubclass = std::static_pointer_cast<File>(fileResult);
645     EXPECT_EQ(16, fileSubclass->GetSize());
646     auto fileValue = fileSubclass->GetValue();
647     EXPECT_TRUE(std::holds_alternative<std::string>(fileValue));
648 
649     fclose(file);
650     LOG_INFO(UDMF_TEST, "WritingAndReadingFile_001 end.");
651 }
652 }
653