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
37using namespace testing::ext;
38using namespace OHOS::UDMF;
39using namespace OHOS;
40
41namespace OHOS::Test {
42class TlvUtilTest : public testing::Test {
43public:
44    static void SetUpTestCase(void);
45
46    static void TearDownTestCase(void);
47
48    void SetUp();
49
50    void TearDown();
51};
52
53void TlvUtilTest::SetUpTestCase(void) {}
54void TlvUtilTest::TearDownTestCase(void) {}
55void TlvUtilTest::SetUp(void) {}
56void TlvUtilTest::TearDown(void) {}
57
58/* *
59 * @tc.name: CountBufferSize_001
60 * @tc.desc: test fundamental for countBufferSize
61 * @tc.type: FUNC
62 */
63HWTEST_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 */
105HWTEST_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    auto total = tlvObject.GetTotal();
127    EXPECT_EQ(188, total);
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 */
136HWTEST_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 */
164HWTEST_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(19 * sizeof(TLVHead) + sizeof(bool) + sizeof(size_t) + 2 * sizeof(int64_t) + 2 * 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 */
191HWTEST_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 */
282HWTEST_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
303    std::vector<uint8_t> dataBytes;
304    auto tlvObject = TLVObject(dataBytes);
305    EXPECT_TRUE(TLVUtil::Writing(runtime, tlvObject, TAG::TAG_RUNTIME));
306
307    tlvObject.ResetCursor();
308    Runtime runtimeResult;
309    EXPECT_TRUE(TLVUtil::ReadTlv(runtimeResult, tlvObject, TAG::TAG_RUNTIME));
310    EXPECT_EQ(runtime.key.key, runtimeResult.key.key);
311    EXPECT_EQ(runtime.key.key, runtimeResult.key.key);
312    EXPECT_EQ(runtime.dataStatus, runtimeResult.dataStatus);
313    EXPECT_EQ(runtime.createTime, runtimeResult.createTime);
314    EXPECT_EQ(runtime.dataVersion, runtimeResult.dataVersion);
315    EXPECT_EQ(runtime.createPackage, runtimeResult.createPackage);
316    EXPECT_EQ(runtime.isPrivate, runtimeResult.isPrivate);
317    EXPECT_EQ(runtime.privileges[0].readPermission, runtimeResult.privileges[0].readPermission);
318    EXPECT_EQ(runtime.privileges[0].tokenId, runtimeResult.privileges[0].tokenId);
319    EXPECT_EQ(runtime.privileges[1].writePermission, runtimeResult.privileges[1].writePermission);
320    EXPECT_EQ(runtime.privileges[1].tokenId, runtimeResult.privileges[1].tokenId);
321
322    LOG_INFO(UDMF_TEST, "WritingAndReading_002 end.");
323}
324
325/* *
326 * @tc.name: WritingAndReading_003
327 * @tc.desc: test UnifiedData for Writing And Reading
328 * @tc.type: FUNC
329 */
330HWTEST_F(TlvUtilTest, WritingAndReading_003, TestSize.Level1)
331{
332    LOG_INFO(UDMF_TEST, "WritingAndReading_003 begin.");
333
334    std::map<std::string, ValueType> value;
335    value["fileType"] = "File Type";
336    value["fileUri"] = "File Uri";
337    std::shared_ptr<Object> obj = std::make_shared<Object>();
338    obj->value_ = value;
339    std::shared_ptr<UnifiedRecord> fileUri = std::make_shared<UnifiedRecord>(UDType::FILE_URI, obj);
340
341    std::shared_ptr<UnifiedRecord> plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, "this is a content");
342    std::shared_ptr<UnifiedRecord> html = std::make_shared<Html>(UDType::HTML, "this is a HTML content");
343
344    std::vector<std::shared_ptr<UnifiedRecord>> records = { fileUri, plainText, html };
345
346    UnifiedData data1;
347    data1.SetRecords(records);
348
349    std::shared_ptr<SystemDefinedAppItem> appItem =
350        std::make_shared<SystemDefinedAppItem>(UDType::SYSTEM_DEFINED_APP_ITEM, "OTHER param");
351    appItem->SetAppId("com.demo");
352    std::shared_ptr<ApplicationDefinedRecord> defineRecord =
353        std::make_shared<ApplicationDefinedRecord>(UDType::APPLICATION_DEFINED_RECORD, "OTHER param");
354    std::vector<uint8_t> u8Vector = { 1, 2, 3, 4 };
355    defineRecord->SetRawData(u8Vector);
356    std::shared_ptr<UnifiedRecord> file = std::make_shared<File>(UDType::FILE, "this is a oriUri");
357
358    std::vector<std::shared_ptr<UnifiedRecord>> records2 = { appItem, defineRecord, file };
359
360    UnifiedData data2;
361    data2.SetRecords(records2);
362
363    std::vector<UnifiedData> datas = { data1, data2 };
364
365    std::vector<uint8_t> dataBytes;
366    auto tlvObject = TLVObject(dataBytes);
367
368    UdmfConversion::InitValueObject(datas);
369    EXPECT_TRUE(TLVUtil::Writing(datas, tlvObject, TAG::TAG_UNIFIED_DATA));
370
371    tlvObject.ResetCursor();
372    std::vector<UnifiedData> datasResult;
373
374    EXPECT_TRUE(TLVUtil::ReadTlv(datasResult, tlvObject, TAG::TAG_UNIFIED_DATA));
375    EXPECT_EQ(2, datasResult.size());
376    UdmfConversion::ConvertRecordToSubclass(datasResult);
377
378    auto recordsResult = datasResult[0].GetRecords();
379    EXPECT_EQ(3, recordsResult.size());
380
381    auto fileUriResult = recordsResult[0];
382    EXPECT_EQ(UDType::FILE_URI, fileUriResult->GetType());
383    auto fileUriValue = fileUriResult->GetValue();
384    EXPECT_TRUE(std::holds_alternative<std::shared_ptr<Object>>(fileUriValue));
385    auto fileUriObj = std::get<std::shared_ptr<Object>>(fileUriValue);
386    EXPECT_EQ("File Uri", std::get<std::string>(fileUriObj->value_["fileUri"]));
387    EXPECT_EQ("File Type", std::get<std::string>(fileUriObj->value_["fileType"]));
388
389    auto plainTextResult = recordsResult[1];
390    EXPECT_EQ(UDType::PLAIN_TEXT, plainTextResult->GetType());
391    auto plainTextSubclass = std::static_pointer_cast<PlainText>(plainTextResult);
392    EXPECT_EQ("this is a content", plainTextSubclass->GetContent());
393    auto plainTextValue = plainTextSubclass->GetValue();
394    EXPECT_TRUE(std::holds_alternative<std::string>(plainTextValue));
395
396    auto htmlResult = recordsResult[2];
397    EXPECT_EQ(UDType::HTML, htmlResult->GetType());
398    auto htmlSubclass = std::static_pointer_cast<Html>(htmlResult);
399    EXPECT_EQ("this is a HTML content", htmlSubclass->GetHtmlContent());
400    auto htmlValue = htmlSubclass->GetValue();
401    EXPECT_TRUE(std::holds_alternative<std::string>(htmlValue));
402
403    auto recordsResult2 = datasResult[1].GetRecords();
404    EXPECT_EQ(3, recordsResult2.size());
405    auto appItemResult = recordsResult2[0];
406    EXPECT_EQ(UDType::SYSTEM_DEFINED_APP_ITEM, appItemResult->GetType());
407    auto appItemSubclass = std::static_pointer_cast<SystemDefinedAppItem>(appItemResult);
408    EXPECT_EQ("com.demo", appItemSubclass->GetAppId());
409    auto appItemValue = appItemSubclass->GetValue();
410    EXPECT_TRUE(std::holds_alternative<std::string>(appItemValue));
411
412    auto defineRecordResult = recordsResult2[1];
413    EXPECT_EQ(UDType::APPLICATION_DEFINED_RECORD, defineRecordResult->GetType());
414    auto adefineRecordSubclass = std::static_pointer_cast<ApplicationDefinedRecord>(defineRecordResult);
415    auto u8VectorResult = adefineRecordSubclass->GetRawData();
416    EXPECT_EQ(4, u8VectorResult.size());
417    auto adefineRecordValue = adefineRecordSubclass->GetValue();
418    EXPECT_TRUE(std::holds_alternative<std::string>(adefineRecordValue));
419
420    auto fileResult = recordsResult2[2];
421    EXPECT_EQ(UDType::FILE, fileResult->GetType());
422    auto fileSubclass = std::static_pointer_cast<File>(fileResult);
423    EXPECT_EQ(16, fileSubclass->GetSize());
424    auto fileValue = fileSubclass->GetValue();
425    EXPECT_TRUE(std::holds_alternative<std::string>(fileValue));
426
427    LOG_INFO(UDMF_TEST, "WritingAndReading_003 end.");
428}
429
430/* *
431 * @tc.name: WritingAndReading_004
432 * @tc.desc: test UnifiedData for Writing And Reading
433 * @tc.type: FUNC
434 */
435HWTEST_F(TlvUtilTest, WritingAndReading_004, TestSize.Level1)
436{
437    LOG_INFO(UDMF_TEST, "WritingAndReading_004 begin.");
438
439    uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
440    OHOS::Media::InitializationOptions opts = { { 5, 7 },
441        Media::PixelFormat::ARGB_8888,
442        Media::PixelFormat::ARGB_8888 };
443    std::unique_ptr<OHOS::Media::PixelMap> pixelMap =
444        OHOS::Media::PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
445    std::shared_ptr<OHOS::Media::PixelMap> pixelMapIn = move(pixelMap);
446    std::map<std::string, ValueType> value;
447    value["pixelMap"] = pixelMapIn;
448    std::shared_ptr<Object> obj = std::make_shared<Object>();
449    obj->value_ = value;
450    std::shared_ptr<UnifiedRecord> pixelMapRecord =
451        std::make_shared<SystemDefinedPixelMap>(UDType::SYSTEM_DEFINED_PIXEL_MAP, obj);
452
453    std::shared_ptr<SystemDefinedForm> form =
454        std::make_shared<SystemDefinedForm>(UDType::SYSTEM_DEFINED_FORM, "Other parm");
455    form->SetFormName("HAPPY DAY");
456
457    UDDetails details;
458    details.emplace("name", "ZhangSan");
459    details.emplace("age", 30);
460    details.emplace("isFemal", true);
461    std::shared_ptr<SystemDefinedRecord> definedRecord =
462        std::make_shared<SystemDefinedRecord>(UDType::SYSTEM_DEFINED_RECORD, "Other parm");
463    definedRecord->SetDetails(details);
464    std::vector<std::shared_ptr<UnifiedRecord>> records = { pixelMapRecord, form, definedRecord };
465
466    UnifiedData data;
467    data.SetRecords(records);
468
469    std::vector<UnifiedData> datas = { data };
470
471    std::vector<uint8_t> dataBytes;
472    auto tlvObject = TLVObject(dataBytes);
473
474    UdmfConversion::InitValueObject(datas);
475    EXPECT_TRUE(TLVUtil::Writing(datas, tlvObject, TAG::TAG_UNIFIED_DATA));
476
477    tlvObject.ResetCursor();
478    std::vector<UnifiedData> datasResult;
479
480    EXPECT_TRUE(TLVUtil::ReadTlv(datasResult, tlvObject, TAG::TAG_UNIFIED_DATA));
481    EXPECT_EQ(1, datasResult.size());
482    UdmfConversion::ConvertRecordToSubclass(datasResult);
483
484    auto recordsResult = datasResult[0].GetRecords();
485    EXPECT_EQ(3, recordsResult.size());
486
487    auto pixelMapRecordResult = recordsResult[0];
488    EXPECT_EQ(UDType::SYSTEM_DEFINED_PIXEL_MAP, pixelMapRecordResult->GetType());
489    auto pixelMapValue = pixelMapRecordResult->GetValue();
490    EXPECT_TRUE(std::holds_alternative<std::shared_ptr<Object>>(pixelMapValue));
491    auto pixelMapObj = std::get<std::shared_ptr<Object>>(pixelMapValue);
492    EXPECT_TRUE(std::holds_alternative<std::shared_ptr<OHOS::Media::PixelMap>>(pixelMapObj->value_["pixelMap"]));
493    auto piexelMapResult = std::get<std::shared_ptr<OHOS::Media::PixelMap>>(pixelMapObj->value_["pixelMap"]);
494    EXPECT_EQ(7, piexelMapResult->GetHeight());
495
496    auto formResult = recordsResult[1];
497    EXPECT_EQ(UDType::SYSTEM_DEFINED_FORM, formResult->GetType());
498    auto formSubclass = std::static_pointer_cast<SystemDefinedForm>(formResult);
499    EXPECT_EQ("HAPPY DAY", formSubclass->GetFormName());
500    auto formValue = formSubclass->GetValue();
501    EXPECT_TRUE(std::holds_alternative<std::string>(formValue));
502
503    auto definedRecordResult = recordsResult[2];
504    EXPECT_EQ(UDType::SYSTEM_DEFINED_RECORD, definedRecordResult->GetType());
505    auto definedRecordSubclass = std::static_pointer_cast<SystemDefinedRecord>(definedRecordResult);
506    auto detailsRecord = definedRecordSubclass->GetDetails();
507    EXPECT_EQ("ZhangSan", std::get<std::string>(detailsRecord["name"]));
508    EXPECT_EQ(30, std::get<int32_t>(detailsRecord["age"]));
509    EXPECT_TRUE(std::get<bool>(detailsRecord["isFemal"]));
510    auto definedRecordValue = definedRecordSubclass->GetValue();
511    EXPECT_TRUE(std::holds_alternative<std::string>(definedRecordValue));
512
513    LOG_INFO(UDMF_TEST, "WritingAndReading_004 end.");
514}
515
516/* *
517 * @tc.name: WritingAndReading_005
518 * @tc.desc: test Want for Writing And Reading
519 * @tc.type: FUNC
520 */
521HWTEST_F(TlvUtilTest, WritingAndReading_005, TestSize.Level1)
522{
523    LOG_INFO(UDMF_TEST, "WritingAndReading_005 begin.");
524    std::shared_ptr<OHOS::AAFwk::Want> want = std::make_shared<OHOS::AAFwk::Want>();
525    std::string idKey = "id";
526    int32_t idValue = 123;
527    want->SetParam(idKey, idValue);
528    std::map<std::string, ValueType> value;
529    value["want"] = want;
530    std::shared_ptr<Object> obj = std::make_shared<Object>();
531    obj->value_ = value;
532
533    std::vector<uint8_t> dataBytes;
534    auto tlvObject = TLVObject(dataBytes);
535
536    EXPECT_TRUE(TLVUtil::Writing(obj, tlvObject, TAG::TAG_OBJECT_VALUE));
537    tlvObject.ResetCursor();
538    std::shared_ptr<Object> objResult = std::make_shared<Object>();
539    EXPECT_TRUE(TLVUtil::ReadTlv(objResult, tlvObject, TAG::TAG_OBJECT_VALUE));
540    auto valueResult = objResult->value_;
541    EXPECT_TRUE(std::holds_alternative<std::shared_ptr<OHOS::AAFwk::Want>>(valueResult["want"]));
542    auto wantResult = std::get<std::shared_ptr<OHOS::AAFwk::Want>>(valueResult["want"]);
543    EXPECT_EQ(idValue, wantResult->GetIntParam(idKey, 0));
544    LOG_INFO(UDMF_TEST, "WritingAndReading_005 end.");
545}
546
547/* *
548 * @tc.name: WritingAndReadingFile_001
549 * @tc.desc: test Unified Data for Writing And Reading
550 * @tc.type: FUNC
551 */
552HWTEST_F(TlvUtilTest, WritingAndReadingFile_001, TestSize.Level1)
553{
554    LOG_INFO(UDMF_TEST, "WritingAndReadingFile_001 begin.");
555    std::map<std::string, ValueType> value;
556    value["fileType"] = "File Type";
557    value["fileUri"] = "File Uri";
558    std::shared_ptr<Object> obj = std::make_shared<Object>();
559    obj->value_ = value;
560    std::shared_ptr<UnifiedRecord> fileUri = std::make_shared<UnifiedRecord>(UDType::FILE_URI, obj);
561
562    std::shared_ptr<UnifiedRecord> plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, "this is a content");
563    std::shared_ptr<UnifiedRecord> html = std::make_shared<Html>(UDType::HTML, "this is a HTML content");
564
565    std::vector<std::shared_ptr<UnifiedRecord>> records = { fileUri, plainText, html };
566
567    UnifiedData data1;
568    data1.SetRecords(records);
569
570    std::shared_ptr<SystemDefinedAppItem> appItem =
571        std::make_shared<SystemDefinedAppItem>(UDType::SYSTEM_DEFINED_APP_ITEM, "OTHER param");
572    appItem->SetAppId("com.demo");
573    std::shared_ptr<ApplicationDefinedRecord> defineRecord =
574        std::make_shared<ApplicationDefinedRecord>(UDType::APPLICATION_DEFINED_RECORD, "OTHER param");
575    std::vector<uint8_t> u8Vector = { 1, 2, 3, 4 };
576    defineRecord->SetRawData(u8Vector);
577    std::shared_ptr<UnifiedRecord> fileRecord = std::make_shared<File>(UDType::FILE, "this is a oriUri");
578
579    std::vector<std::shared_ptr<UnifiedRecord>> records2 = { appItem, defineRecord, fileRecord };
580
581    UnifiedData data2;
582    data2.SetRecords(records2);
583
584    std::vector<UnifiedData> datas = { data1, data2 };
585
586    std::string dataFile = "demo1";
587    std::vector<uint8_t> dataBytes;
588    auto tlvObject = TLVObject(dataBytes);
589
590    std::FILE *file = fopen(dataFile.c_str(), "w+");
591    tlvObject.SetFile(file);
592    UdmfConversion::InitValueObject(datas);
593    EXPECT_TRUE(TLVUtil::Writing(datas, tlvObject, TAG::TAG_UNIFIED_DATA));
594
595    tlvObject.ResetCursor();
596    std::vector<UnifiedData> datasResult;
597
598    EXPECT_TRUE(TLVUtil::ReadTlv(datasResult, tlvObject, TAG::TAG_UNIFIED_DATA));
599    EXPECT_EQ(2, datasResult.size());
600    UdmfConversion::ConvertRecordToSubclass(datasResult);
601
602    auto recordsResult = datasResult[0].GetRecords();
603    EXPECT_EQ(3, recordsResult.size());
604
605    auto fileUriResult = recordsResult[0];
606    EXPECT_EQ(UDType::FILE_URI, fileUriResult->GetType());
607    auto fileUriValue = fileUriResult->GetValue();
608    EXPECT_TRUE(std::holds_alternative<std::shared_ptr<Object>>(fileUriValue));
609    auto fileUriObj = std::get<std::shared_ptr<Object>>(fileUriValue);
610    EXPECT_EQ("File Uri", std::get<std::string>(fileUriObj->value_["fileUri"]));
611    EXPECT_EQ("File Type", std::get<std::string>(fileUriObj->value_["fileType"]));
612
613    auto plainTextResult = recordsResult[1];
614    EXPECT_EQ(UDType::PLAIN_TEXT, plainTextResult->GetType());
615    auto plainTextSubclass = std::static_pointer_cast<PlainText>(plainTextResult);
616    EXPECT_EQ("this is a content", plainTextSubclass->GetContent());
617    auto plainTextValue = plainTextSubclass->GetValue();
618    EXPECT_TRUE(std::holds_alternative<std::string>(plainTextValue));
619
620    auto htmlResult = recordsResult[2];
621    EXPECT_EQ(UDType::HTML, htmlResult->GetType());
622    auto htmlSubclass = std::static_pointer_cast<Html>(htmlResult);
623    EXPECT_EQ("this is a HTML content", htmlSubclass->GetHtmlContent());
624    auto htmlValue = htmlSubclass->GetValue();
625    EXPECT_TRUE(std::holds_alternative<std::string>(htmlValue));
626
627    auto recordsResult2 = datasResult[1].GetRecords();
628    EXPECT_EQ(3, recordsResult2.size());
629    auto appItemResult = recordsResult2[0];
630    EXPECT_EQ(UDType::SYSTEM_DEFINED_APP_ITEM, appItemResult->GetType());
631    auto appItemSubclass = std::static_pointer_cast<SystemDefinedAppItem>(appItemResult);
632    EXPECT_EQ("com.demo", appItemSubclass->GetAppId());
633    auto appItemValue = appItemSubclass->GetValue();
634    EXPECT_TRUE(std::holds_alternative<std::string>(appItemValue));
635
636    auto defineRecordResult = recordsResult2[1];
637    EXPECT_EQ(UDType::APPLICATION_DEFINED_RECORD, defineRecordResult->GetType());
638    auto adefineRecordSubclass = std::static_pointer_cast<ApplicationDefinedRecord>(defineRecordResult);
639    auto u8VectorResult = adefineRecordSubclass->GetRawData();
640    EXPECT_EQ(4, u8VectorResult.size());
641    auto adefineRecordValue = adefineRecordSubclass->GetValue();
642    EXPECT_TRUE(std::holds_alternative<std::string>(adefineRecordValue));
643
644    auto fileResult = recordsResult2[2];
645    EXPECT_EQ(UDType::FILE, fileResult->GetType());
646    auto fileSubclass = std::static_pointer_cast<File>(fileResult);
647    EXPECT_EQ(16, fileSubclass->GetSize());
648    auto fileValue = fileSubclass->GetValue();
649    EXPECT_TRUE(std::holds_alternative<std::string>(fileValue));
650
651    fclose(file);
652    LOG_INFO(UDMF_TEST, "WritingAndReadingFile_001 end.");
653}
654}
655