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 #include "convert_utils.h"
17 
18 #include <gtest/gtest.h>
19 #include <paste_data.h>
20 #include <unified_data.h>
21 
22 #include "paste_data_entry.h"
23 #include "tlv_object.h"
24 #include "unified_meta.h"
25 
26 namespace OHOS::MiscServices {
27 using namespace testing::ext;
28 using namespace testing;
29 using namespace OHOS::Media;
30 class ConvertUtilsTest : public testing::Test {
31 public:
32     static void SetUpTestCase(void);
33     static void TearDownTestCase(void);
34     void SetUp();
35     void TearDown();
36 
37 protected:
38     std::string text_ = "test";
39     std::string extraText_ = "extr";
40     std::string uri_ = "";
41     std::string html_ = "<div class='disable'>helloWorld</div>";
42     std::string link_ = "http://abc.com";
43     std::string appUtdId1_ = "appdefined-mytype1";
44     std::string appUtdId2_ = "appdefined-mytype2";
45     std::vector<uint8_t> rawData1_ = { 1, 2, 3, 4, 5, 6, 7, 8 };
46     std::vector<uint8_t> rawData2_ = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
47 
48     void CheckEntries(const std::vector<std::shared_ptr<PasteDataEntry>>& entries);
49     void CheckPlainUds(const std::shared_ptr<PasteDataEntry> entry);
50     void CheckFileUriUds(const std::shared_ptr<PasteDataEntry> entry);
51     void CheckPixelMapUds(const std::shared_ptr<PasteDataEntry> entry);
52     void CheckHtmlUds(const std::shared_ptr<PasteDataEntry> entry);
53     void CheckLinkUds(const std::shared_ptr<PasteDataEntry> entry);
54     void CheckCustomEntry(const std::shared_ptr<PasteDataEntry> entry);
55 
56     void InitDataWithEntries(UDMF::UnifiedData& data);
57     void InitDataWithPlainEntry(UDMF::UnifiedData& data);
58     void InitDataWithHtmlEntry(UDMF::UnifiedData& data);
59     void InitDataWithFileUriEntry(UDMF::UnifiedData& data);
60     void InitDataWithPixelMapEntry(UDMF::UnifiedData& data);
61     void InitDataWitCustomEntry(UDMF::UnifiedData& data);
62     void InitDataWitSameCustomEntry(UDMF::UnifiedData& data);
63 
64     void AddPlainUdsEntry(UDMF::UnifiedRecord& record);
65     void AddFileUriUdsEntry(UDMF::UnifiedRecord& record);
66     void AddHtmlUdsEntry(UDMF::UnifiedRecord& record);
67     void AddPixelMapUdsEntry(UDMF::UnifiedRecord& record);
68     void AddLinkUdsEntry(UDMF::UnifiedRecord& record);
69     void AddCustomEntry(UDMF::UnifiedRecord& record);
70     void AddCustomEntries(UDMF::UnifiedRecord& record);
71 
72     static PasteData TlvData(const std::shared_ptr<PasteData>& data);
73 };
74 
SetUpTestCase(void)75 void ConvertUtilsTest::SetUpTestCase(void) {}
76 
TearDownTestCase(void)77 void ConvertUtilsTest::TearDownTestCase(void) {}
78 
SetUp(void)79 void ConvertUtilsTest::SetUp(void) {}
80 
TearDown(void)81 void ConvertUtilsTest::TearDown(void) {}
82 
TlvData(const std::shared_ptr<PasteData> & data)83 PasteData ConvertUtilsTest::TlvData(const std::shared_ptr<PasteData>& data)
84 {
85     std::vector<std::uint8_t> buffer;
86     data->Init(buffer);
87     data->Encode(buffer);
88     PasteData decodePasteData;
89     decodePasteData.Decode(buffer);
90     return decodePasteData;
91 }
92 
AddPlainUdsEntry(UDMF::UnifiedRecord & record)93 void ConvertUtilsTest::AddPlainUdsEntry(UDMF::UnifiedRecord& record)
94 {
95     Object plainUds;
96     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
97     plainUds.value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
98     plainUds.value_[UDMF::CONTENT] = text_;
99     record.AddEntry(utdId, std::make_shared<Object>(plainUds));
100 }
101 
AddFileUriUdsEntry(UDMF::UnifiedRecord & record)102 void ConvertUtilsTest::AddFileUriUdsEntry(UDMF::UnifiedRecord& record)
103 {
104     Object fileUriobject;
105     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI);
106     fileUriobject.value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
107     fileUriobject.value_[UDMF::FILE_URI_PARAM] = uri_;
108     fileUriobject.value_[UDMF::FILE_TYPE] = "";
109     record.AddEntry(utdId, std::make_shared<Object>(fileUriobject));
110 }
111 
AddHtmlUdsEntry(UDMF::UnifiedRecord & record)112 void ConvertUtilsTest::AddHtmlUdsEntry(UDMF::UnifiedRecord& record)
113 {
114     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML);
115     Object htmlobject;
116     htmlobject.value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
117     htmlobject.value_[UDMF::HTML_CONTENT] = html_;
118     record.AddEntry(utdId, std::make_shared<Object>(htmlobject));
119 }
120 
AddLinkUdsEntry(UDMF::UnifiedRecord & record)121 void ConvertUtilsTest::AddLinkUdsEntry(UDMF::UnifiedRecord& record)
122 {
123     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK);
124     Object linkObject;
125     linkObject.value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
126     linkObject.value_[UDMF::URL] = link_;
127     record.AddEntry(utdId, std::make_shared<Object>(linkObject));
128 }
129 
AddCustomEntry(UDMF::UnifiedRecord & record)130 void ConvertUtilsTest::AddCustomEntry(UDMF::UnifiedRecord& record)
131 {
132     record.AddEntry(appUtdId1_, rawData1_);
133 }
134 
AddCustomEntries(UDMF::UnifiedRecord & record)135 void ConvertUtilsTest::AddCustomEntries(UDMF::UnifiedRecord& record)
136 {
137     record.AddEntry(appUtdId1_, rawData1_);
138     record.AddEntry(appUtdId2_, rawData2_);
139 }
140 
AddPixelMapUdsEntry(UDMF::UnifiedRecord & record)141 void ConvertUtilsTest::AddPixelMapUdsEntry(UDMF::UnifiedRecord& record)
142 {
143     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP);
144     Object object;
145     object.value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
146     uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
147     InitializationOptions opts = { { 5, 7 }, PixelFormat::ARGB_8888, PixelFormat::ARGB_8888 };
148     std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
149     std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
150     object.value_[UDMF::PIXEL_MAP] = pixelMapIn;
151     record.AddEntry(utdId, std::make_shared<Object>(object));
152 }
153 
InitDataWithPlainEntry(UDMF::UnifiedData & data)154 void ConvertUtilsTest::InitDataWithPlainEntry(UDMF::UnifiedData& data)
155 {
156     std::shared_ptr<UDMF::UnifiedRecord> record = std::make_shared<UDMF::UnifiedRecord>();
157     AddPlainUdsEntry(*record);
158     data.AddRecord(record);
159     auto size = data.GetRecords().size();
160     ASSERT_EQ(1, size);
161     auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
162     ASSERT_EQ(1, entriesSize);
163 }
164 
InitDataWithHtmlEntry(UDMF::UnifiedData & data)165 void ConvertUtilsTest::InitDataWithHtmlEntry(UDMF::UnifiedData& data)
166 {
167     std::shared_ptr<UDMF::UnifiedRecord> record = std::make_shared<UDMF::UnifiedRecord>();
168     AddHtmlUdsEntry(*record);
169     data.AddRecord(record);
170     auto size = data.GetRecords().size();
171     ASSERT_EQ(1, size);
172     auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
173     ASSERT_EQ(1, entriesSize);
174 }
175 
InitDataWithFileUriEntry(UDMF::UnifiedData & data)176 void ConvertUtilsTest::InitDataWithFileUriEntry(UDMF::UnifiedData& data)
177 {
178     std::shared_ptr<UDMF::UnifiedRecord> record = std::make_shared<UDMF::UnifiedRecord>();
179     AddFileUriUdsEntry(*record);
180     data.AddRecord(record);
181     auto size = data.GetRecords().size();
182     ASSERT_EQ(1, size);
183     auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
184     ASSERT_EQ(1, entriesSize);
185 }
186 
InitDataWithPixelMapEntry(UDMF::UnifiedData & data)187 void ConvertUtilsTest::InitDataWithPixelMapEntry(UDMF::UnifiedData& data)
188 {
189     std::shared_ptr<UDMF::UnifiedRecord> record = std::make_shared<UDMF::UnifiedRecord>();
190     AddPixelMapUdsEntry(*record);
191     data.AddRecord(record);
192     auto size = data.GetRecords().size();
193     ASSERT_EQ(1, size);
194     auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
195     ASSERT_EQ(1, entriesSize);
196 }
197 
InitDataWitCustomEntry(UDMF::UnifiedData & data)198 void ConvertUtilsTest::InitDataWitCustomEntry(UDMF::UnifiedData& data)
199 {
200     std::shared_ptr<UDMF::UnifiedRecord> record = std::make_shared<UDMF::UnifiedRecord>();
201     AddCustomEntry(*record);
202     data.AddRecord(record);
203     auto size = data.GetRecords().size();
204     ASSERT_EQ(1, size);
205     auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
206     ASSERT_EQ(1, entriesSize);
207 }
208 
InitDataWitSameCustomEntry(UDMF::UnifiedData & data)209 void ConvertUtilsTest::InitDataWitSameCustomEntry(UDMF::UnifiedData& data)
210 {
211     std::shared_ptr<UDMF::UnifiedRecord> record = std::make_shared<UDMF::UnifiedRecord>();
212     AddCustomEntry(*record);
213     record->AddEntry(appUtdId1_, rawData2_);
214     data.AddRecord(record);
215     auto size = data.GetRecords().size();
216     ASSERT_EQ(1, size);
217     auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
218     ASSERT_EQ(1, entriesSize);
219 }
220 
InitDataWithEntries(UDMF::UnifiedData & data)221 void ConvertUtilsTest::InitDataWithEntries(UDMF::UnifiedData& data)
222 {
223     std::shared_ptr<UDMF::UnifiedRecord> record = std::make_shared<UDMF::UnifiedRecord>();
224     AddPlainUdsEntry(*record);
225     AddHtmlUdsEntry(*record);
226     AddFileUriUdsEntry(*record);
227     AddLinkUdsEntry(*record);
228     AddCustomEntries(*record);
229     auto entriesSize = record->GetEntries()->size();
230     ASSERT_EQ(6, entriesSize);
231     data.AddRecord(record);
232     auto size = data.GetRecords().size();
233     ASSERT_EQ(1, size);
234 }
235 
CheckEntries(const std::vector<std::shared_ptr<PasteDataEntry>> & entries)236 void ConvertUtilsTest::CheckEntries(const std::vector<std::shared_ptr<PasteDataEntry>>& entries)
237 {
238     for (auto const& entry : entries) {
239         if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT)) {
240             CheckPlainUds(entry);
241         } else if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI)) {
242             CheckFileUriUds(entry);
243         } else if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP)) {
244             CheckPixelMapUds(entry);
245         } else if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK)) {
246             CheckLinkUds(entry);
247         } else if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML)) {
248             CheckHtmlUds(entry);
249         } else {
250             CheckCustomEntry(entry);
251         }
252     }
253 }
254 
CheckPlainUds(const std::shared_ptr<PasteDataEntry> entry)255 void ConvertUtilsTest::CheckPlainUds(const std::shared_ptr<PasteDataEntry> entry)
256 {
257     ASSERT_NE(entry, nullptr);
258     ASSERT_EQ(MIMETYPE_TEXT_PLAIN, entry->GetMimeType());
259     auto decodeValue = entry->GetValue();
260     auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
261     ASSERT_NE(object, nullptr);
262     auto objectValue = (*object)->value_;
263     auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
264     ASSERT_NE(typeValue, nullptr);
265     ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT));
266     auto value = std::get_if<std::string>(&objectValue[UDMF::CONTENT]);
267     ASSERT_NE(value, nullptr);
268     ASSERT_EQ(*value, text_);
269 }
270 
CheckFileUriUds(const std::shared_ptr<PasteDataEntry> entry)271 void ConvertUtilsTest::CheckFileUriUds(const std::shared_ptr<PasteDataEntry> entry)
272 {
273     ASSERT_NE(entry, nullptr);
274     ASSERT_EQ(MIMETYPE_TEXT_URI, entry->GetMimeType());
275     auto decodeValue = entry->GetValue();
276     auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
277     ASSERT_NE(object, nullptr);
278     auto objectValue = (*object)->value_;
279     auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
280     ASSERT_NE(typeValue, nullptr);
281     ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI));
282     auto value = std::get_if<std::string>(&objectValue[UDMF::FILE_URI_PARAM]);
283     ASSERT_NE(value, nullptr);
284     ASSERT_EQ(*value, uri_);
285 }
286 
CheckHtmlUds(const std::shared_ptr<PasteDataEntry> entry)287 void ConvertUtilsTest::CheckHtmlUds(const std::shared_ptr<PasteDataEntry> entry)
288 {
289     ASSERT_NE(entry, nullptr);
290     ASSERT_EQ(MIMETYPE_TEXT_HTML, entry->GetMimeType());
291     auto decodeValue = entry->GetValue();
292     auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
293     ASSERT_NE(object, nullptr);
294     auto objectValue = (*object)->value_;
295     auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
296     ASSERT_NE(typeValue, nullptr);
297     ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML));
298     auto value = std::get_if<std::string>(&objectValue[UDMF::HTML_CONTENT]);
299     ASSERT_NE(value, nullptr);
300     ASSERT_EQ(*value, html_);
301 }
302 
CheckPixelMapUds(const std::shared_ptr<PasteDataEntry> entry)303 void ConvertUtilsTest::CheckPixelMapUds(const std::shared_ptr<PasteDataEntry> entry)
304 {
305     ASSERT_NE(entry, nullptr);
306     ASSERT_EQ(MIMETYPE_PIXELMAP, entry->GetMimeType());
307     auto decodeValue = entry->GetValue();
308     auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
309     ASSERT_NE(object, nullptr);
310     auto objectValue = (*object)->value_;
311     auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
312     ASSERT_NE(typeValue, nullptr);
313     ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP));
314     auto value = std::get_if<std::shared_ptr<PixelMap>>(&objectValue[UDMF::PIXEL_MAP]);
315     ASSERT_NE(value, nullptr);
316     ImageInfo imageInfo = {};
317     (*value)->GetImageInfo(imageInfo);
318     ASSERT_TRUE(imageInfo.size.height == 7);
319     ASSERT_TRUE(imageInfo.size.width == 5);
320     ASSERT_TRUE(imageInfo.pixelFormat == PixelFormat::ARGB_8888);
321 }
322 
CheckLinkUds(const std::shared_ptr<PasteDataEntry> entry)323 void ConvertUtilsTest::CheckLinkUds(const std::shared_ptr<PasteDataEntry> entry)
324 {
325     ASSERT_NE(entry, nullptr);
326     ASSERT_EQ(MIMETYPE_TEXT_PLAIN, entry->GetMimeType());
327     auto decodeValue = entry->GetValue();
328     auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
329     ASSERT_NE(object, nullptr);
330     auto objectValue = (*object)->value_;
331     auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
332     ASSERT_NE(typeValue, nullptr);
333     ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK));
334     auto value = std::get_if<std::string>(&objectValue[UDMF::URL]);
335     ASSERT_NE(value, nullptr);
336     ASSERT_EQ(*value, link_);
337 }
338 
CheckCustomEntry(const std::shared_ptr<PasteDataEntry> entry)339 void ConvertUtilsTest::CheckCustomEntry(const std::shared_ptr<PasteDataEntry> entry)
340 {
341     ASSERT_NE(entry, nullptr);
342     ASSERT_EQ(entry->GetUtdId(), entry->GetMimeType());
343     auto decodeValue = entry->GetValue();
344     auto object = std::get_if<std::vector<uint8_t>>(&decodeValue);
345     ASSERT_NE(object, nullptr);
346     if (entry->GetUtdId() == appUtdId1_) {
347         ASSERT_EQ(*object, rawData1_);
348     } else {
349         ASSERT_EQ(*object, rawData2_);
350     }
351 }
352 
353 /**
354 * @tc.name: PlainEntryTest001
355 * @tc.desc:
356 * @tc.type: FUNC
357 * @tc.require:
358 * @tc.author:tarowang
359 */
360 HWTEST_F(ConvertUtilsTest, PlainEntryTest001, TestSize.Level0)
361 {
362     UDMF::UnifiedData data;
363     InitDataWithPlainEntry(data);
364     auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
365     auto pasteData = ConvertUtils::Convert(data);
366     auto decodePasteData = TlvData(pasteData);
367     ASSERT_EQ(1, decodePasteData.GetRecordCount());
368     auto record = decodePasteData.GetRecordAt(0);
369     auto type = record->GetMimeType();
370     ASSERT_EQ(type, MIMETYPE_TEXT_PLAIN);
371     auto udType = record->GetUDType();
372     ASSERT_EQ(udType, UDMF::UDType::PLAIN_TEXT);
373     auto plain = record->GetPlainText();
374     ASSERT_EQ(*plain, text_);
375     auto entries = record->GetEntries();
376     ASSERT_EQ(entries.size(), entriesSize);
377     CheckEntries(entries);
378 }
379 
380 /**
381 * @tc.name: HtmlEntryTest001
382 * @tc.desc:
383 * @tc.type: FUNC
384 * @tc.require:
385 * @tc.author:tarowang
386 */
387 HWTEST_F(ConvertUtilsTest, HtmlEntryTest001, TestSize.Level0)
388 {
389     UDMF::UnifiedData data;
390     InitDataWithHtmlEntry(data);
391     auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
392     auto pasteData = ConvertUtils::Convert(data);
393     auto decodePasteData = TlvData(pasteData);
394     ASSERT_EQ(1, decodePasteData.GetRecordCount());
395     auto record = decodePasteData.GetRecordAt(0);
396     auto type = record->GetMimeType();
397     ASSERT_EQ(type, MIMETYPE_TEXT_HTML);
398     auto udType = record->GetUDType();
399     ASSERT_EQ(udType, UDMF::UDType::HTML);
400     auto plain = record->GetHtmlText();
401     ASSERT_EQ(*plain, html_);
402     auto entries = record->GetEntries();
403     ASSERT_EQ(entries.size(), entriesSize);
404     CheckEntries(entries);
405 }
406 
407 /**
408 * @tc.name: PixelMapEntryTest001
409 * @tc.desc:
410 * @tc.type: FUNC
411 * @tc.require:
412 * @tc.author:tarowang
413 */
414 HWTEST_F(ConvertUtilsTest, PixelMapEntryTest001, TestSize.Level0)
415 {
416     UDMF::UnifiedData data;
417     InitDataWithPixelMapEntry(data);
418     auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
419     auto pasteData = ConvertUtils::Convert(data);
420     auto decodePasteData = TlvData(pasteData);
421     ASSERT_EQ(1, decodePasteData.GetRecordCount());
422     auto record = decodePasteData.GetRecordAt(0);
423     auto type = record->GetMimeType();
424     ASSERT_EQ(type, MIMETYPE_PIXELMAP);
425     auto udType = record->GetUDType();
426     ASSERT_EQ(udType, UDMF::UDType::SYSTEM_DEFINED_PIXEL_MAP);
427     auto pixelMap = record->GetPixelMap();
428     ASSERT_NE(pixelMap, nullptr);
429     ImageInfo imageInfo = {};
430     pixelMap->GetImageInfo(imageInfo);
431     ASSERT_TRUE(imageInfo.size.height == 7);
432     ASSERT_TRUE(imageInfo.size.width == 5);
433     ASSERT_TRUE(imageInfo.pixelFormat == PixelFormat::ARGB_8888);
434     auto entries = record->GetEntries();
435     ASSERT_EQ(entries.size(), entriesSize);
436     CheckEntries(entries);
437 }
438 
439 /**
440 * @tc.name: EntriesTest001
441 * @tc.desc:
442 * @tc.type: FUNC
443 * @tc.require:
444 * @tc.author:tarowang
445 */
446 HWTEST_F(ConvertUtilsTest, EntriesTest001, TestSize.Level0)
447 {
448     UDMF::UnifiedData data;
449     InitDataWithEntries(data);
450     auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
451     auto pasteData = ConvertUtils::Convert(data);
452     auto decodePasteData = TlvData(pasteData);
453     ASSERT_EQ(1, decodePasteData.GetRecordCount());
454     auto record = decodePasteData.GetRecordAt(0);
455     auto type = record->GetMimeType();
456     ASSERT_EQ(type, MIMETYPE_TEXT_PLAIN);
457     auto udType = record->GetUDType();
458     ASSERT_EQ(udType, UDMF::UDType::PLAIN_TEXT);
459     auto plain = record->GetPlainText();
460     ASSERT_NE(plain, nullptr);
461     ASSERT_EQ(*plain, text_);
462 
463     auto entries = record->GetEntries();
464     ASSERT_EQ(entries.size(), entriesSize);
465     CheckEntries(entries);
466 }
467 
468 /**
469 * @tc.name: SameTypeEntryTest001
470 * @tc.desc:
471 * @tc.type: FUNC
472 * @tc.require:
473 * @tc.author:tarowang
474 */
475 HWTEST_F(ConvertUtilsTest, SameTypeEntryTest001, TestSize.Level0)
476 {
477     UDMF::UnifiedData data;
478     InitDataWitSameCustomEntry(data);
479     auto pasteData = ConvertUtils::Convert(data);
480     auto decodePasteData = TlvData(pasteData);
481     ASSERT_EQ(1, decodePasteData.GetRecordCount());
482     auto record = decodePasteData.GetRecordAt(0);
483     auto type = record->GetMimeType();
484     ASSERT_EQ(type, appUtdId1_);
485     auto udType = record->GetUDType();
486     ASSERT_EQ(udType, UDMF::UDType::APPLICATION_DEFINED_RECORD);
487     auto customData = record->GetCustomData();
488     ASSERT_NE(customData, nullptr);
489     auto rawData = customData->GetItemData();
490     ASSERT_EQ(rawData.size(), 1);
491     ASSERT_EQ(rawData[appUtdId1_], rawData2_);
492 }
493 } // namespace OHOS::MiscServices