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 "pasteboard_hilog.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->Encode(buffer);
86 PasteData decodePasteData;
87 decodePasteData.Decode(buffer);
88 return decodePasteData;
89 }
90
AddPlainUdsEntry(UDMF::UnifiedRecord & record)91 void ConvertUtilsTest::AddPlainUdsEntry(UDMF::UnifiedRecord &record)
92 {
93 Object plainUds;
94 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
95 plainUds.value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
96 plainUds.value_[UDMF::CONTENT] = text_;
97 record.AddEntry(utdId, std::make_shared<Object>(plainUds));
98 }
99
AddFileUriUdsEntry(UDMF::UnifiedRecord & record)100 void ConvertUtilsTest::AddFileUriUdsEntry(UDMF::UnifiedRecord &record)
101 {
102 Object fileUriobject;
103 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI);
104 fileUriobject.value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
105 fileUriobject.value_[UDMF::FILE_URI_PARAM] = uri_;
106 fileUriobject.value_[UDMF::FILE_TYPE] = "";
107 record.AddEntry(utdId, std::make_shared<Object>(fileUriobject));
108 }
109
AddHtmlUdsEntry(UDMF::UnifiedRecord & record)110 void ConvertUtilsTest::AddHtmlUdsEntry(UDMF::UnifiedRecord &record)
111 {
112 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML);
113 Object htmlobject;
114 htmlobject.value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
115 htmlobject.value_[UDMF::HTML_CONTENT] = html_;
116 record.AddEntry(utdId, std::make_shared<Object>(htmlobject));
117 }
118
AddLinkUdsEntry(UDMF::UnifiedRecord & record)119 void ConvertUtilsTest::AddLinkUdsEntry(UDMF::UnifiedRecord &record)
120 {
121 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK);
122 Object linkObject;
123 linkObject.value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
124 linkObject.value_[UDMF::URL] = link_;
125 record.AddEntry(utdId, std::make_shared<Object>(linkObject));
126 }
127
AddCustomEntry(UDMF::UnifiedRecord & record)128 void ConvertUtilsTest::AddCustomEntry(UDMF::UnifiedRecord &record)
129 {
130 record.AddEntry(appUtdId1_, rawData1_);
131 }
132
AddCustomEntries(UDMF::UnifiedRecord & record)133 void ConvertUtilsTest::AddCustomEntries(UDMF::UnifiedRecord &record)
134 {
135 record.AddEntry(appUtdId1_, rawData1_);
136 record.AddEntry(appUtdId2_, rawData2_);
137 }
138
AddPixelMapUdsEntry(UDMF::UnifiedRecord & record)139 void ConvertUtilsTest::AddPixelMapUdsEntry(UDMF::UnifiedRecord &record)
140 {
141 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP);
142 Object object;
143 object.value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
144 uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
145 InitializationOptions opts = {
146 {5, 7},
147 PixelFormat::ARGB_8888, PixelFormat::ARGB_8888
148 };
149 std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
150 std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
151 object.value_[UDMF::PIXEL_MAP] = pixelMapIn;
152 record.AddEntry(utdId, std::make_shared<Object>(object));
153 }
154
InitDataWithPlainEntry(UDMF::UnifiedData & data)155 void ConvertUtilsTest::InitDataWithPlainEntry(UDMF::UnifiedData &data)
156 {
157 std::shared_ptr<UDMF::UnifiedRecord> record = std::make_shared<UDMF::UnifiedRecord>();
158 AddPlainUdsEntry(*record);
159 data.AddRecord(record);
160 auto size = data.GetRecords().size();
161 ASSERT_EQ(1, size);
162 auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
163 ASSERT_EQ(1, entriesSize);
164 }
165
InitDataWithHtmlEntry(UDMF::UnifiedData & data)166 void ConvertUtilsTest::InitDataWithHtmlEntry(UDMF::UnifiedData &data)
167 {
168 std::shared_ptr<UDMF::UnifiedRecord> record = std::make_shared<UDMF::UnifiedRecord>();
169 AddHtmlUdsEntry(*record);
170 data.AddRecord(record);
171 auto size = data.GetRecords().size();
172 ASSERT_EQ(1, size);
173 auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
174 ASSERT_EQ(1, entriesSize);
175 }
176
InitDataWithFileUriEntry(UDMF::UnifiedData & data)177 void ConvertUtilsTest::InitDataWithFileUriEntry(UDMF::UnifiedData &data)
178 {
179 std::shared_ptr<UDMF::UnifiedRecord> record = std::make_shared<UDMF::UnifiedRecord>();
180 AddFileUriUdsEntry(*record);
181 data.AddRecord(record);
182 auto size = data.GetRecords().size();
183 ASSERT_EQ(1, size);
184 auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
185 ASSERT_EQ(1, entriesSize);
186 }
187
InitDataWithPixelMapEntry(UDMF::UnifiedData & data)188 void ConvertUtilsTest::InitDataWithPixelMapEntry(UDMF::UnifiedData &data)
189 {
190 std::shared_ptr<UDMF::UnifiedRecord> record = std::make_shared<UDMF::UnifiedRecord>();
191 AddPixelMapUdsEntry(*record);
192 data.AddRecord(record);
193 auto size = data.GetRecords().size();
194 ASSERT_EQ(1, size);
195 auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
196 ASSERT_EQ(1, entriesSize);
197 }
198
InitDataWitCustomEntry(UDMF::UnifiedData & data)199 void ConvertUtilsTest::InitDataWitCustomEntry(UDMF::UnifiedData &data)
200 {
201 std::shared_ptr<UDMF::UnifiedRecord> record = std::make_shared<UDMF::UnifiedRecord>();
202 AddCustomEntry(*record);
203 data.AddRecord(record);
204 auto size = data.GetRecords().size();
205 ASSERT_EQ(1, size);
206 auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
207 ASSERT_EQ(1, entriesSize);
208 }
209
InitDataWitSameCustomEntry(UDMF::UnifiedData & data)210 void ConvertUtilsTest::InitDataWitSameCustomEntry(UDMF::UnifiedData &data)
211 {
212 std::shared_ptr<UDMF::UnifiedRecord> record = std::make_shared<UDMF::UnifiedRecord>();
213 AddCustomEntry(*record);
214 record->AddEntry(appUtdId1_, rawData2_);
215 data.AddRecord(record);
216 auto size = data.GetRecords().size();
217 ASSERT_EQ(1, size);
218 auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
219 ASSERT_EQ(1, entriesSize);
220 }
221
InitDataWithEntries(UDMF::UnifiedData & data)222 void ConvertUtilsTest::InitDataWithEntries(UDMF::UnifiedData &data)
223 {
224 std::shared_ptr<UDMF::UnifiedRecord> record = std::make_shared<UDMF::UnifiedRecord>();
225 AddPlainUdsEntry(*record);
226 AddHtmlUdsEntry(*record);
227 AddFileUriUdsEntry(*record);
228 AddLinkUdsEntry(*record);
229 AddCustomEntries(*record);
230 auto entriesSize = record->GetEntries()->size();
231 ASSERT_EQ(6, entriesSize);
232 data.AddRecord(record);
233 auto size = data.GetRecords().size();
234 ASSERT_EQ(1, size);
235 }
236
CheckEntries(const std::vector<std::shared_ptr<PasteDataEntry>> & entries)237 void ConvertUtilsTest::CheckEntries(const std::vector<std::shared_ptr<PasteDataEntry>> &entries)
238 {
239 for (auto const &entry : entries) {
240 if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT)) {
241 CheckPlainUds(entry);
242 } else if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI)) {
243 CheckFileUriUds(entry);
244 } else if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP)) {
245 CheckPixelMapUds(entry);
246 } else if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK)) {
247 CheckLinkUds(entry);
248 } else if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML)) {
249 CheckHtmlUds(entry);
250 } else {
251 CheckCustomEntry(entry);
252 }
253 }
254 }
255
CheckPlainUds(const std::shared_ptr<PasteDataEntry> entry)256 void ConvertUtilsTest::CheckPlainUds(const std::shared_ptr<PasteDataEntry> entry)
257 {
258 ASSERT_NE(entry, nullptr);
259 ASSERT_EQ(MIMETYPE_TEXT_PLAIN, entry->GetMimeType());
260 auto decodeValue = entry->GetValue();
261 auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
262 ASSERT_NE(object, nullptr);
263 auto objectValue = (*object)->value_;
264 auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
265 ASSERT_NE(typeValue, nullptr);
266 ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT));
267 auto value = std::get_if<std::string>(&objectValue[UDMF::CONTENT]);
268 ASSERT_NE(value, nullptr);
269 ASSERT_EQ(*value, text_);
270 }
271
CheckFileUriUds(const std::shared_ptr<PasteDataEntry> entry)272 void ConvertUtilsTest::CheckFileUriUds(const std::shared_ptr<PasteDataEntry> entry)
273 {
274 ASSERT_NE(entry, nullptr);
275 ASSERT_EQ(MIMETYPE_TEXT_URI, entry->GetMimeType());
276 auto decodeValue = entry->GetValue();
277 auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
278 ASSERT_NE(object, nullptr);
279 auto objectValue = (*object)->value_;
280 auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
281 ASSERT_NE(typeValue, nullptr);
282 ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI));
283 auto value = std::get_if<std::string>(&objectValue[UDMF::FILE_URI_PARAM]);
284 ASSERT_NE(value, nullptr);
285 ASSERT_EQ(*value, uri_);
286 }
287
CheckHtmlUds(const std::shared_ptr<PasteDataEntry> entry)288 void ConvertUtilsTest::CheckHtmlUds(const std::shared_ptr<PasteDataEntry> entry)
289 {
290 ASSERT_NE(entry, nullptr);
291 ASSERT_EQ(MIMETYPE_TEXT_HTML, entry->GetMimeType());
292 auto decodeValue = entry->GetValue();
293 auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
294 ASSERT_NE(object, nullptr);
295 auto objectValue = (*object)->value_;
296 auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
297 ASSERT_NE(typeValue, nullptr);
298 ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML));
299 auto value = std::get_if<std::string>(&objectValue[UDMF::HTML_CONTENT]);
300 ASSERT_NE(value, nullptr);
301 ASSERT_EQ(*value, html_);
302 }
303
CheckPixelMapUds(const std::shared_ptr<PasteDataEntry> entry)304 void ConvertUtilsTest::CheckPixelMapUds(const std::shared_ptr<PasteDataEntry> entry)
305 {
306 ASSERT_NE(entry, nullptr);
307 ASSERT_EQ(MIMETYPE_PIXELMAP, entry->GetMimeType());
308 auto decodeValue = entry->GetValue();
309 auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
310 ASSERT_NE(object, nullptr);
311 auto objectValue = (*object)->value_;
312 auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
313 ASSERT_NE(typeValue, nullptr);
314 ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP));
315 auto value = std::get_if<std::shared_ptr<PixelMap>>(&objectValue[UDMF::PIXEL_MAP]);
316 ASSERT_NE(value, nullptr);
317 ImageInfo imageInfo = {};
318 (*value)->GetImageInfo(imageInfo);
319 ASSERT_TRUE(imageInfo.size.height == 7);
320 ASSERT_TRUE(imageInfo.size.width == 5);
321 ASSERT_TRUE(imageInfo.pixelFormat == PixelFormat::ARGB_8888);
322 }
323
CheckLinkUds(const std::shared_ptr<PasteDataEntry> entry)324 void ConvertUtilsTest::CheckLinkUds(const std::shared_ptr<PasteDataEntry> entry)
325 {
326 ASSERT_NE(entry, nullptr);
327 ASSERT_EQ(MIMETYPE_TEXT_PLAIN, entry->GetMimeType());
328 auto decodeValue = entry->GetValue();
329 auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
330 ASSERT_NE(object, nullptr);
331 auto objectValue = (*object)->value_;
332 auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
333 ASSERT_NE(typeValue, nullptr);
334 ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK));
335 auto value = std::get_if<std::string>(&objectValue[UDMF::URL]);
336 ASSERT_NE(value, nullptr);
337 ASSERT_EQ(*value, link_);
338 }
339
CheckCustomEntry(const std::shared_ptr<PasteDataEntry> entry)340 void ConvertUtilsTest::CheckCustomEntry(const std::shared_ptr<PasteDataEntry> entry)
341 {
342 ASSERT_NE(entry, nullptr);
343 ASSERT_EQ(entry->GetUtdId(), entry->GetMimeType());
344 auto decodeValue = entry->GetValue();
345 auto object = std::get_if<std::vector<uint8_t>>(&decodeValue);
346 ASSERT_NE(object, nullptr);
347 if (entry->GetUtdId() == appUtdId1_) {
348 ASSERT_EQ(*object, rawData1_);
349 } else {
350 ASSERT_EQ(*object, rawData2_);
351 }
352 }
353
354 /**
355 * @tc.name: PlainEntryTest001
356 * @tc.desc:
357 * @tc.type: FUNC
358 * @tc.require:
359 * @tc.author:tarowang
360 */
361 HWTEST_F(ConvertUtilsTest, PlainEntryTest001, TestSize.Level0)
362 {
363 UDMF::UnifiedData data;
364 InitDataWithPlainEntry(data);
365 auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
366 auto pasteData = ConvertUtils::Convert(data);
367 auto decodePasteData = TlvData(pasteData);
368 ASSERT_EQ(1, decodePasteData.GetRecordCount());
369 auto record = decodePasteData.GetRecordAt(0);
370 auto type = record->GetMimeType();
371 ASSERT_EQ(type, MIMETYPE_TEXT_PLAIN);
372 auto udType = record->GetUDType();
373 ASSERT_EQ(udType, UDMF::UDType::PLAIN_TEXT);
374 auto plain = record->GetPlainText();
375 ASSERT_EQ(*plain, text_);
376 auto entries = record->GetEntries();
377 ASSERT_EQ(entries.size(), entriesSize);
378 CheckEntries(entries);
379 }
380
381 /**
382 * @tc.name: HtmlEntryTest001
383 * @tc.desc:
384 * @tc.type: FUNC
385 * @tc.require:
386 * @tc.author:tarowang
387 */
388 HWTEST_F(ConvertUtilsTest, HtmlEntryTest001, TestSize.Level0)
389 {
390 UDMF::UnifiedData data;
391 InitDataWithHtmlEntry(data);
392 auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
393 auto pasteData = ConvertUtils::Convert(data);
394 auto decodePasteData = TlvData(pasteData);
395 ASSERT_EQ(1, decodePasteData.GetRecordCount());
396 auto record = decodePasteData.GetRecordAt(0);
397 auto type = record->GetMimeType();
398 ASSERT_EQ(type, MIMETYPE_TEXT_HTML);
399 auto udType = record->GetUDType();
400 ASSERT_EQ(udType, UDMF::UDType::HTML);
401 auto plain = record->GetHtmlText();
402 ASSERT_EQ(*plain, html_);
403 auto entries = record->GetEntries();
404 ASSERT_EQ(entries.size(), entriesSize);
405 CheckEntries(entries);
406 }
407
408 /**
409 * @tc.name: PixelMapEntryTest001
410 * @tc.desc:
411 * @tc.type: FUNC
412 * @tc.require:
413 * @tc.author:tarowang
414 */
415 HWTEST_F(ConvertUtilsTest, PixelMapEntryTest001, TestSize.Level0)
416 {
417 UDMF::UnifiedData data;
418 InitDataWithPixelMapEntry(data);
419 auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
420 auto pasteData = ConvertUtils::Convert(data);
421 auto decodePasteData = TlvData(pasteData);
422 ASSERT_EQ(1, decodePasteData.GetRecordCount());
423 auto record = decodePasteData.GetRecordAt(0);
424 auto type = record->GetMimeType();
425 ASSERT_EQ(type, MIMETYPE_PIXELMAP);
426 auto udType = record->GetUDType();
427 ASSERT_EQ(udType, UDMF::UDType::SYSTEM_DEFINED_PIXEL_MAP);
428 auto pixelMap = record->GetPixelMap();
429 ASSERT_NE(pixelMap, nullptr);
430 ImageInfo imageInfo = {};
431 pixelMap->GetImageInfo(imageInfo);
432 ASSERT_TRUE(imageInfo.size.height == 7);
433 ASSERT_TRUE(imageInfo.size.width == 5);
434 ASSERT_TRUE(imageInfo.pixelFormat == PixelFormat::ARGB_8888);
435 auto entries = record->GetEntries();
436 ASSERT_EQ(entries.size(), entriesSize);
437 CheckEntries(entries);
438 }
439
440 /**
441 * @tc.name: EntriesTest001
442 * @tc.desc:
443 * @tc.type: FUNC
444 * @tc.require:
445 * @tc.author:tarowang
446 */
447 HWTEST_F(ConvertUtilsTest, EntriesTest001, TestSize.Level0)
448 {
449 UDMF::UnifiedData data;
450 InitDataWithEntries(data);
451 auto entriesSize = data.GetRecordAt(0)->GetEntries()->size();
452 auto pasteData = ConvertUtils::Convert(data);
453 auto decodePasteData = TlvData(pasteData);
454 ASSERT_EQ(1, decodePasteData.GetRecordCount());
455 auto record = decodePasteData.GetRecordAt(0);
456 auto type = record->GetMimeType();
457 ASSERT_EQ(type, MIMETYPE_TEXT_PLAIN);
458 auto udType = record->GetUDType();
459 ASSERT_EQ(udType, UDMF::UDType::PLAIN_TEXT);
460 auto plain = record->GetPlainText();
461 ASSERT_NE(plain, nullptr);
462 ASSERT_EQ(*plain, text_);
463
464 auto entries = record->GetEntries();
465 ASSERT_EQ(entries.size(), entriesSize);
466 CheckEntries(entries);
467 }
468
469 /**
470 * @tc.name: SameTypeEntryTest001
471 * @tc.desc:
472 * @tc.type: FUNC
473 * @tc.require:
474 * @tc.author:tarowang
475 */
476 HWTEST_F(ConvertUtilsTest, SameTypeEntryTest001, TestSize.Level0)
477 {
478 UDMF::UnifiedData data;
479 InitDataWitSameCustomEntry(data);
480 auto pasteData = ConvertUtils::Convert(data);
481 auto decodePasteData = TlvData(pasteData);
482 ASSERT_EQ(1, decodePasteData.GetRecordCount());
483 auto record = decodePasteData.GetRecordAt(0);
484 auto type = record->GetMimeType();
485 ASSERT_EQ(type, appUtdId1_);
486 auto udType = record->GetUDType();
487 ASSERT_EQ(udType, UDMF::UDType::APPLICATION_DEFINED_RECORD);
488 auto customData = record->GetCustomData();
489 ASSERT_NE(customData, nullptr);
490 auto rawData = customData->GetItemData();
491 ASSERT_EQ(rawData.size(), 1);
492 ASSERT_EQ(rawData[appUtdId1_], rawData2_);
493 }
494
495 /**
496 * @tc.name: ConvertPropertyTest001
497 * @tc.desc: Test ConvertProperty function when properties is nullptr
498 * @tc.type: FUNC
499 * @tc.require:
500 */
501 HWTEST_F(ConvertUtilsTest, ConvertPropertyTest001, TestSize.Level0)
502 {
503 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertPropertyTest001 start");
504 std::shared_ptr<UDMF::UnifiedDataProperties> properties = nullptr;
505 UDMF::UnifiedData unifiedData;
506 PasteDataProperty result;
507
508 result.shareOption = InApp;
509 result = ConvertUtils::ConvertProperty(properties, unifiedData);
510 EXPECT_EQ(result.shareOption, 0);
511
512 result.shareOption = LocalDevice;
513 result = ConvertUtils::ConvertProperty(properties, unifiedData);
514 EXPECT_EQ(result.shareOption, 0);
515
516 result.shareOption = CrossDevice;
517 result = ConvertUtils::ConvertProperty(properties, unifiedData);
518 EXPECT_EQ(result.shareOption, 0);
519
520 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertPropertyTest001 end");
521 }
522
523 /**
524 * @tc.name: ConvertPropertyTest002
525 * @tc.desc: Test ConvertProperty function when properties->shareOptions is UDMF::IN_APP
526 * @tc.type: FUNC
527 * @tc.require:
528 */
529 HWTEST_F(ConvertUtilsTest, ConvertPropertyTest002, TestSize.Level0)
530 {
531 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertPropertyTest002 start");
532 std::shared_ptr<UDMF::UnifiedDataProperties> properties = std::make_shared<UDMF::UnifiedDataProperties>();
533 UDMF::UnifiedData unifiedData;
534 PasteDataProperty result;
535
536 properties->shareOptions = UDMF::IN_APP;
537 result.shareOption = LocalDevice;
538 result = ConvertUtils::ConvertProperty(properties, unifiedData);
539 EXPECT_EQ(result.shareOption, InApp);
540 result.shareOption = CrossDevice;
541 result = ConvertUtils::ConvertProperty(properties, unifiedData);
542 EXPECT_EQ(result.shareOption, InApp);
543 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertPropertyTest002 end");
544 }
545
546 /**
547 * @tc.name: ConvertPropertyTest003
548 * @tc.desc: Test ConvertProperty function when properties->shareOptions is UDMF::CROSS_APP
549 * @tc.type: FUNC
550 * @tc.require:
551 */
552 HWTEST_F(ConvertUtilsTest, ConvertPropertyTest003, TestSize.Level0)
553 {
554 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertPropertyTest003 start");
555 std::shared_ptr<UDMF::UnifiedDataProperties> properties = std::make_shared<UDMF::UnifiedDataProperties>();
556 UDMF::UnifiedData unifiedData;
557 PasteDataProperty result;
558
559 properties->shareOptions = UDMF::CROSS_APP;
560 result.shareOption = InApp;
561 result = ConvertUtils::ConvertProperty(properties, unifiedData);
562 EXPECT_EQ(result.shareOption, LocalDevice);
563 result.shareOption = CrossDevice;
564 result = ConvertUtils::ConvertProperty(properties, unifiedData);
565 EXPECT_EQ(result.shareOption, LocalDevice);
566
567 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertPropertyTest003 end");
568 }
569
570 /**
571 * @tc.name: ConvertPropertyTest004
572 * @tc.desc: Test ConvertProperty function when properties->shareOptions is UDMF::CROSS_DEVICE
573 * @tc.type: FUNC
574 * @tc.require:
575 */
576 HWTEST_F(ConvertUtilsTest, ConvertPropertyTest004, TestSize.Level0)
577 {
578 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertPropertyTest004 start");
579 std::shared_ptr<UDMF::UnifiedDataProperties> properties = std::make_shared<UDMF::UnifiedDataProperties>();
580 UDMF::UnifiedData unifiedData;
581 PasteDataProperty result;
582
583 properties->shareOptions = UDMF::CROSS_DEVICE;
584 result.shareOption = InApp;
585 result = ConvertUtils::ConvertProperty(properties, unifiedData);
586 EXPECT_EQ(result.shareOption, CrossDevice);
587 result.shareOption = CrossDevice;
588 result = ConvertUtils::ConvertProperty(properties, unifiedData);
589 EXPECT_EQ(result.shareOption, CrossDevice);
590
591 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertPropertyTest004 end");
592 }
593
594 /**
595 * @tc.name: ConvertPropertyTest005
596 * @tc.desc: Test ConvertProperty function when properties->shareOptions is UDMF::SHARE_OPTIONS_BUTT
597 * @tc.type: FUNC
598 * @tc.require:
599 */
600 HWTEST_F(ConvertUtilsTest, ConvertPropertyTest005, TestSize.Level0)
601 {
602 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertPropertyTest005 start");
603 std::shared_ptr<UDMF::UnifiedDataProperties> properties = std::make_shared<UDMF::UnifiedDataProperties>();
604 UDMF::UnifiedData unifiedData;
605 PasteDataProperty result;
606
607 properties->shareOptions = UDMF::SHARE_OPTIONS_BUTT;
608 result.shareOption = InApp;
609 result = ConvertUtils::ConvertProperty(properties, unifiedData);
610 EXPECT_EQ(result.shareOption, CrossDevice);
611 result.shareOption = CrossDevice;
612 result = ConvertUtils::ConvertProperty(properties, unifiedData);
613 EXPECT_EQ(result.shareOption, CrossDevice);
614
615 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertPropertyTest005 end");
616 }
617
618 /**
619 * @tc.name: ConvertPropertyTest006
620 * @tc.desc: Test ConvertProperty function when properties.shareOption is InApp
621 * @tc.type: FUNC
622 * @tc.require:
623 */
624 HWTEST_F(ConvertUtilsTest, ConvertPropertyTest006, TestSize.Level0)
625 {
626 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertPropertyTest006 start");
627 PasteDataProperty properties;
628 std::shared_ptr<UDMF::UnifiedDataProperties> result = std::make_shared<UDMF::UnifiedDataProperties>();
629
630 properties.shareOption = InApp;
631 result->shareOptions = UDMF::CROSS_APP;
632 result = ConvertUtils::ConvertProperty(properties);
633 EXPECT_EQ(result->shareOptions, UDMF::IN_APP);
634 result->shareOptions = UDMF::CROSS_DEVICE;
635 result = ConvertUtils::ConvertProperty(properties);
636 EXPECT_EQ(result->shareOptions, UDMF::IN_APP);
637
638 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertPropertyTest006 end");
639 }
640
641 /**
642 * @tc.name: ConvertPropertyTest007
643 * @tc.desc: Test ConvertProperty function when properties.shareOption is LocalDevice
644 * @tc.type: FUNC
645 * @tc.require:
646 */
647 HWTEST_F(ConvertUtilsTest, ConvertPropertyTest007, TestSize.Level0)
648 {
649 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertPropertyTest007 start");
650 PasteDataProperty properties;
651 std::shared_ptr<UDMF::UnifiedDataProperties> result = std::make_shared<UDMF::UnifiedDataProperties>();
652
653 properties.shareOption = LocalDevice;
654 result->shareOptions = UDMF::IN_APP;
655 result = ConvertUtils::ConvertProperty(properties);
656 EXPECT_EQ(result->shareOptions, UDMF::CROSS_APP);
657 result->shareOptions = UDMF::CROSS_DEVICE;
658 result = ConvertUtils::ConvertProperty(properties);
659 EXPECT_EQ(result->shareOptions, UDMF::CROSS_APP);
660
661 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertPropertyTest007 end");
662 }
663
664 /**
665 * @tc.name: ConvertPropertyTest008
666 * @tc.desc: Test ConvertProperty function when properties.shareOption is CrossDevice
667 * @tc.type: FUNC
668 * @tc.require:
669 */
670 HWTEST_F(ConvertUtilsTest, ConvertPropertyTest008, TestSize.Level0)
671 {
672 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertPropertyTest008 start");
673 PasteDataProperty properties;
674 std::shared_ptr<UDMF::UnifiedDataProperties> result = std::make_shared<UDMF::UnifiedDataProperties>();
675
676 properties.shareOption = CrossDevice;
677 result->shareOptions = UDMF::IN_APP;
678 result = ConvertUtils::ConvertProperty(properties);
679 EXPECT_EQ(result->shareOptions, UDMF::CROSS_DEVICE);
680 result->shareOptions = UDMF::CROSS_APP;
681 result = ConvertUtils::ConvertProperty(properties);
682 EXPECT_EQ(result->shareOptions, UDMF::CROSS_DEVICE);
683
684 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertPropertyTest008 end");
685 }
686
687 /**
688 * @tc.name: ConvertPlainTextTest
689 * @tc.desc: Test convert function when UNIFROM_DATA_TYPE is PLAIN_TEXT
690 * @tc.type: FUNC
691 * @tc.require:
692 */
693 HWTEST_F(ConvertUtilsTest, ConvertPlainTextTest, TestSize.Level0)
694 {
695 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
696 std::shared_ptr<PasteDataRecord> record = std::make_shared<PasteDataRecord>();
697 std::shared_ptr<PasteDataEntry> entry = std::make_shared<PasteDataEntry>(utdId, text_);
698 ASSERT_NE(entry, nullptr);
699 record->AddEntry(utdId, entry);
700 ASSERT_NE(record, nullptr);
701 UDMF::ValueType result = ConvertUtils::Convert(entry, record);
702 auto object = std::get_if<std::shared_ptr<Object>>(&result);
703 ASSERT_NE(object, nullptr);
704 auto objectValue = (*object)->value_;
705 if (std::holds_alternative<std::string>(objectValue[UDMF::UNIFORM_DATA_TYPE])) {
706 auto& typeValue = std::get<std::string>(objectValue[UDMF::UNIFORM_DATA_TYPE]);
707 ASSERT_NE(&typeValue, nullptr);
708 ASSERT_EQ(typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT));
709 }
710 if (std::holds_alternative<std::string>(objectValue[UDMF::CONTENT])) {
711 auto& value = std::get<std::string>(objectValue[UDMF::CONTENT]);
712 ASSERT_NE(&value, nullptr);
713 ASSERT_EQ(value, text_);
714 }
715 }
716
717 /**
718 * @tc.name: ConvertHtmlTest
719 * @tc.desc: Test convert function when UNIFROM_DATA_TYPE is HTML
720 * @tc.type: FUNC
721 * @tc.require:
722 */
723 HWTEST_F(ConvertUtilsTest, ConvertHtmlTest, TestSize.Level0)
724 {
725 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML);
726 std::shared_ptr<PasteDataRecord> record = std::make_shared<PasteDataRecord>();
727 std::shared_ptr<PasteDataEntry> entry = std::make_shared<PasteDataEntry>(utdId, html_);
728 ASSERT_NE(entry, nullptr);
729 record->AddEntry(utdId, entry);
730 ASSERT_NE(record, nullptr);
731 UDMF::ValueType result = ConvertUtils::Convert(entry, record);
732 auto object = std::get_if<std::shared_ptr<Object>>(&result);
733 ASSERT_NE(object, nullptr);
734 auto objectValue = (*object)->value_;
735 if (std::holds_alternative<std::string>(objectValue[UDMF::UNIFORM_DATA_TYPE])) {
736 auto& typeValue = std::get<std::string>(objectValue[UDMF::UNIFORM_DATA_TYPE]);
737 ASSERT_NE(&typeValue, nullptr);
738 ASSERT_EQ(typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML));
739 }
740 if (std::holds_alternative<std::string>(objectValue[UDMF::CONTENT])) {
741 auto& value = std::get<std::string>(objectValue[UDMF::CONTENT]);
742 ASSERT_NE(&value, nullptr);
743 ASSERT_EQ(value, html_);
744 }
745 }
746
747 /**
748 * @tc.name: ConvertFileUriTest
749 * @tc.desc: Test convert function when UNIFROM_DATA_TYPE is FILE_URI
750 * @tc.type: FUNC
751 * @tc.require:
752 */
753 HWTEST_F(ConvertUtilsTest, ConvertFileUriTest, TestSize.Level0)
754 {
755 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI);
756 std::shared_ptr<PasteDataRecord> record = std::make_shared<PasteDataRecord>();
757 std::shared_ptr<PasteDataEntry> entry = std::make_shared<PasteDataEntry>(utdId, uri_);
758 ASSERT_NE(entry, nullptr);
759 record->AddEntry(utdId, entry);
760 ASSERT_NE(record, nullptr);
761 UDMF::ValueType result = ConvertUtils::Convert(entry, record);
762 auto object = std::get_if<std::shared_ptr<Object>>(&result);
763 ASSERT_NE(object, nullptr);
764 auto objectValue = (*object)->value_;
765 if (std::holds_alternative<std::string>(objectValue[UDMF::UNIFORM_DATA_TYPE])) {
766 auto& typeValue = std::get<std::string>(objectValue[UDMF::UNIFORM_DATA_TYPE]);
767 ASSERT_NE(&typeValue, nullptr);
768 ASSERT_EQ(typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI));
769 }
770 if (std::holds_alternative<std::string>(objectValue[UDMF::CONTENT])) {
771 auto& value = std::get<std::string>(objectValue[UDMF::CONTENT]);
772 ASSERT_NE(&value, nullptr);
773 ASSERT_EQ(value, uri_);
774 }
775 }
776
777 /**
778 * @tc.name: ConvertPixelMapTest
779 * @tc.desc: Test convert function when UNIFROM_DATA_TYPE is SYSTEM_DEFINED_PIXEL_MAP
780 * @tc.type: FUNC
781 * @tc.require:
782 */
783 HWTEST_F(ConvertUtilsTest, ConvertPixelMapTest, TestSize.Level0)
784 {
785 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP);
786 uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
787 InitializationOptions opts = {
788 {5, 7},
789 PixelFormat::ARGB_8888, PixelFormat::ARGB_8888
790 };
791 std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
792 std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
793 std::shared_ptr<PasteDataRecord> record = std::make_shared<PasteDataRecord>();
794 std::shared_ptr<PasteDataEntry> entry = std::make_shared<PasteDataEntry>(utdId, pixelMapIn);
795 ASSERT_NE(entry, nullptr);
796 record->AddEntry(utdId, entry);
797 ASSERT_NE(record, nullptr);
798 UDMF::ValueType result = ConvertUtils::Convert(entry, record);
799 auto object = std::get_if<std::shared_ptr<Object>>(&result);
800 ASSERT_NE(object, nullptr);
801 auto objectValue = (*object)->value_;
802 if (std::holds_alternative<std::string>(objectValue[UDMF::UNIFORM_DATA_TYPE])) {
803 auto& typeValue = std::get<std::string>(objectValue[UDMF::UNIFORM_DATA_TYPE]);
804 ASSERT_NE(&typeValue, nullptr);
805 ASSERT_EQ(typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP));
806 }
807 if (std::holds_alternative<std::string>(objectValue[UDMF::CONTENT])) {
808 auto& value = std::get<std::string>(objectValue[UDMF::CONTENT]);
809 ASSERT_NE(&value, nullptr);
810 }
811
812 auto inPixelMap = record->GetPixelMap();
813 ASSERT_NE(inPixelMap, nullptr);
814 ImageInfo imageInfo = {};
815 inPixelMap->GetImageInfo(imageInfo);
816 ASSERT_TRUE(imageInfo.size.height == 7);
817 ASSERT_TRUE(imageInfo.size.width == 5);
818 ASSERT_TRUE(imageInfo.pixelFormat == PixelFormat::ARGB_8888);
819 }
820 } // namespace OHOS::MiscServices