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