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