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
18 #include "application_defined_record.h"
19 #include "audio.h"
20 #include "folder.h"
21 #include "html.h"
22 #include "image.h"
23 #include "link.h"
24 #include "pasteboard_utils.h"
25 #include "plain_text.h"
26 #include "pasteboard_hilog.h"
27 #include "system_defined_appitem.h"
28 #include "system_defined_form.h"
29 #include "system_defined_pixelmap.h"
30 #include "video.h"
31 namespace OHOS::MiscServices {
32 using namespace testing::ext;
33 using namespace testing;
34 using namespace OHOS::Media;
35 using UnifiedDataProperties = UDMF::UnifiedDataProperties;
36 class PasteboardUtilsTest : public testing::Test {
37 public:
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
40 void SetUp();
41 void TearDown();
42 UDMF::UnifiedData InitTextData();
43 UDMF::UnifiedData InitPlainData();
44 UDMF::UnifiedData InitHtmlData();
45 UDMF::UnifiedData InitWantData();
46 UDMF::UnifiedData InitLinkData();
47 UDMF::UnifiedData InitFileData();
48 UDMF::UnifiedData InitImageData();
49 UDMF::UnifiedData InitVideoData();
50 UDMF::UnifiedData InitAudioData();
51 UDMF::UnifiedData InitFolderData();
52 UDMF::UnifiedData InitSystemRecordData();
53 UDMF::UnifiedData InitSystemAppItemData();
54 UDMF::UnifiedData InitSystemFormData();
55 UDMF::UnifiedData InitSystemPixelMapData();
56 UDMF::UnifiedData InitAppDefinedData();
57
58 protected:
59 Details details_;
60 std::vector<uint8_t> rawData_;
61 std::string text_;
62 std::string extraText_;
63 std::string uri_;
64 };
65
SetUpTestCase(void)66 void PasteboardUtilsTest::SetUpTestCase(void) { }
67
TearDownTestCase(void)68 void PasteboardUtilsTest::TearDownTestCase(void) { }
69
SetUp(void)70 void PasteboardUtilsTest::SetUp(void)
71 {
72 rawData_ = { 1, 2, 3, 4, 5, 6, 7, 8 };
73 details_.insert({ "keyString", "string_test" });
74 details_.insert({ "keyInt32", 1 });
75 details_.insert({ "keyBool", true });
76 details_.insert({ "KeyU8Array", rawData_ });
77 details_.insert({ "KeyDouble", 1.234 });
78 }
79
TearDown(void)80 void PasteboardUtilsTest::TearDown(void) { }
81
InitTextData()82 UDMF::UnifiedData PasteboardUtilsTest::InitTextData()
83 {
84 UDMF::UnifiedData data;
85 std::shared_ptr<UDMF::Text> textRecord = std::make_shared<UDMF::Text>();
86 textRecord->SetDetails(details_);
87 data.AddRecord(textRecord);
88 return data;
89 }
90
InitPlainData()91 UDMF::UnifiedData PasteboardUtilsTest::InitPlainData()
92 {
93 text_ = "helloWorld_plainText";
94 extraText_ = "helloWorld_plainAbstract";
95 UDMF::UnifiedData data;
96 std::shared_ptr<UDMF::PlainText> plainTextRecord = std::make_shared<UDMF::PlainText>(text_, extraText_);
97 plainTextRecord->SetDetails(details_);
98 data.AddRecord(plainTextRecord);
99 auto unifiedDataProperties = std::make_shared<UnifiedDataProperties>();
100 unifiedDataProperties->isRemote = true;
101 data.SetProperties(unifiedDataProperties);
102 return data;
103 }
104
InitHtmlData()105 UDMF::UnifiedData PasteboardUtilsTest::InitHtmlData()
106 {
107 text_ = "<div class='disable'>helloWorld</div>";
108 extraText_ = "helloWorld_plainAbstract";
109 UDMF::UnifiedData data;
110 std::shared_ptr<UDMF::Html> htmlRecord = std::make_shared<UDMF::Html>(text_, extraText_);
111 htmlRecord->SetDetails(details_);
112 data.AddRecord(htmlRecord);
113 return data;
114 }
InitWantData()115 UDMF::UnifiedData PasteboardUtilsTest::InitWantData()
116 {
117 using namespace OHOS::AAFwk;
118 std::shared_ptr<Want> want = std::make_shared<Want>();
119 std::string idKey = "id";
120 int32_t idValue = 123;
121 std::string deviceKey = "deviceId_key";
122 want->SetParam(idKey, idValue);
123 std::shared_ptr<UDMF::UnifiedRecord> wantRecord =
124 std::make_shared<UDMF::UnifiedRecord>(UDMF::OPENHARMONY_WANT, want);
125 UDMF::UnifiedData data;
126 data.AddRecord(wantRecord);
127 return data;
128 }
129
InitLinkData()130 UDMF::UnifiedData PasteboardUtilsTest::InitLinkData()
131 {
132 text_ = "https://www.test.com";
133 extraText_ = "https://www.test.com/content";
134 UDMF::UnifiedData data;
135 std::shared_ptr<UDMF::Link> linkRecord = std::make_shared<UDMF::Link>(text_, extraText_);
136 linkRecord->SetDetails(details_);
137 data.AddRecord(linkRecord);
138 return data;
139 }
InitFileData()140 UDMF::UnifiedData PasteboardUtilsTest::InitFileData()
141 {
142 UDMF::UnifiedData data;
143 auto typeStr = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE);
144 uri_ = "file:/uri";
145 std::shared_ptr<UDMF::File> fileRecord = std::make_shared<UDMF::File>(uri_);
146 fileRecord->SetDetails(details_);
147 data.AddRecord(fileRecord);
148 return data;
149 }
InitImageData()150 UDMF::UnifiedData PasteboardUtilsTest::InitImageData()
151 {
152 UDMF::UnifiedData data;
153 auto typeStr = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::IMAGE);
154 uri_ = "file:/image";
155 std::shared_ptr<UDMF::Image> imageRecord = std::make_shared<UDMF::Image>(uri_);
156 imageRecord->SetDetails(details_);
157 data.AddRecord(imageRecord);
158 return data;
159 }
InitVideoData()160 UDMF::UnifiedData PasteboardUtilsTest::InitVideoData()
161 {
162 UDMF::UnifiedData data;
163 auto typeStr = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::VIDEO);
164 uri_ = "file:/Video";
165 std::shared_ptr<UDMF::Video> videoRecord = std::make_shared<UDMF::Video>(uri_);
166 videoRecord->SetDetails(details_);
167 data.AddRecord(videoRecord);
168
169 return data;
170 }
InitAudioData()171 UDMF::UnifiedData PasteboardUtilsTest::InitAudioData()
172 {
173 UDMF::UnifiedData data;
174 auto typeStr = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::AUDIO);
175 uri_ = "file:/Audio";
176 std::shared_ptr<UDMF::Audio> audioRecord = std::make_shared<UDMF::Audio>(uri_);
177 audioRecord->SetDetails(details_);
178 data.AddRecord(audioRecord);
179 return data;
180 }
InitFolderData()181 UDMF::UnifiedData PasteboardUtilsTest::InitFolderData()
182 {
183 UDMF::UnifiedData data;
184 auto typeStr = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FOLDER);
185 uri_ = "file:/Folder";
186 std::shared_ptr<UDMF::Folder> folderRecord = std::make_shared<UDMF::Folder>(uri_);
187 folderRecord->SetDetails(details_);
188 data.AddRecord(folderRecord);
189 return data;
190 }
InitSystemRecordData()191 UDMF::UnifiedData PasteboardUtilsTest::InitSystemRecordData()
192 {
193 UDMF::UnifiedData data;
194 std::shared_ptr<UDMF::SystemDefinedRecord> systemRecord = std::make_shared<UDMF::SystemDefinedRecord>();
195 systemRecord->SetDetails(details_);
196 data.AddRecord(systemRecord);
197 return data;
198 }
InitSystemAppItemData()199 UDMF::UnifiedData PasteboardUtilsTest::InitSystemAppItemData()
200 {
201 UDMF::UnifiedData data;
202 std::shared_ptr<UDMF::SystemDefinedAppItem> systemDefinedAppItem1 = std::make_shared<UDMF::SystemDefinedAppItem>();
203 std::string appId = "appId";
204 std::string appIconId = "appIconId";
205 std::string appName = "appName";
206 std::string appLabelId = "appLabelId";
207 std::string bundleName = "bundleName";
208 std::string abilityName = "abilityName";
209 systemDefinedAppItem1->SetDetails(details_);
210 systemDefinedAppItem1->SetAppId(appId);
211 systemDefinedAppItem1->SetAppName(appName);
212 systemDefinedAppItem1->SetAppIconId(appIconId);
213 systemDefinedAppItem1->SetAppLabelId(appLabelId);
214 systemDefinedAppItem1->SetBundleName(bundleName);
215 systemDefinedAppItem1->SetAbilityName(abilityName);
216 systemDefinedAppItem1->SetType(UDMF::SYSTEM_DEFINED_APP_ITEM);
217 data.AddRecord(systemDefinedAppItem1);
218 return data;
219 }
InitSystemFormData()220 UDMF::UnifiedData PasteboardUtilsTest::InitSystemFormData()
221 {
222 UDMF::UnifiedData data;
223 std::shared_ptr<UDMF::SystemDefinedForm> form = std::make_shared<UDMF::SystemDefinedForm>();
224 int32_t formId = 1;
225 std::string formName = "formName";
226 std::string module = "module";
227 std::string bundleName = "bundleName";
228 std::string abilityName = "abilityName";
229 form->SetDetails(details_);
230 form->SetFormId(formId);
231 form->SetFormName(formName);
232 form->SetAbilityName(abilityName);
233 form->SetBundleName(bundleName);
234 form->SetModule(module);
235 form->SetType(UDMF::SYSTEM_DEFINED_FORM);
236 data.AddRecord(form);
237 return data;
238 }
InitSystemPixelMapData()239 UDMF::UnifiedData PasteboardUtilsTest::InitSystemPixelMapData()
240 {
241 uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
242 InitializationOptions opts = {
243 {5, 7},
244 PixelFormat::ARGB_8888, PixelFormat::ARGB_8888
245 };
246 std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
247 std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
248 std::shared_ptr<UDMF::UnifiedRecord> pixelMapRecord =
249 std::make_shared<UDMF::SystemDefinedPixelMap>(UDMF::SYSTEM_DEFINED_PIXEL_MAP, pixelMapIn);
250 UDMF::UnifiedData data;
251 data.AddRecord(pixelMapRecord);
252 return data;
253 }
254
InitAppDefinedData()255 UDMF::UnifiedData PasteboardUtilsTest::InitAppDefinedData()
256 {
257 UDMF::UnifiedData data;
258 std::shared_ptr<UDMF::ApplicationDefinedRecord> appRecord = std::make_shared<UDMF::ApplicationDefinedRecord>();
259 std::map<std::string, std::vector<uint8_t>> customData;
260 customData[UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::APPLICATION_DEFINED_RECORD)] = rawData_;
261 appRecord->SetApplicationDefinedType(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::APPLICATION_DEFINED_RECORD));
262 appRecord->SetRawData(rawData_);
263 data.AddRecord(appRecord);
264 return data;
265 }
266
267 /**
268 * @tc.name: Text2PasteRecord001
269 * @tc.desc: pasteData is local data.
270 * @tc.type: FUNC
271 * @tc.require:
272 * @tc.author:
273 */
274 HWTEST_F(PasteboardUtilsTest, Text2PasteRecord001, TestSize.Level0)
275 {
276 auto data = InitTextData();
277 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
278 ASSERT_EQ(1, pasteData->GetRecordCount());
279 auto record = pasteData->GetRecordAt(0);
280 auto type = record->GetMimeType();
281 ASSERT_EQ(type, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::TEXT));
282 auto udType = record->GetUDType();
283 ASSERT_EQ(udType, UDMF::UDType::TEXT);
284 auto details1 = record->GetDetails();
285 ASSERT_EQ(*details1, details_);
286
287 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
288 ASSERT_EQ(1, newData->GetRecords().size());
289 auto newRecord = newData->GetRecordAt(0);
290 auto newType = newRecord->GetType();
291 ASSERT_EQ(newType, UDMF::TEXT);
292 auto newPlainRecord = static_cast<UDMF::Text *>(newRecord.get());
293 auto newDetails = newPlainRecord->GetDetails();
294 ASSERT_EQ(newDetails, details_);
295 }
296
297 /**
298 * @tc.name: Text2PasteRecord002
299 * @tc.desc: textRecord is nullptr
300 * @tc.type: FUNC
301 * @tc.require:
302 * @tc.author:
303 */
304 HWTEST_F(PasteboardUtilsTest, Text2PasteRecord002, TestSize.Level0)
305 {
306 std::shared_ptr<UDMF::Text> textRecord;
307 auto pasteRecord = PasteboardUtils::Text2PasteRecord(textRecord);
308 ASSERT_EQ(pasteRecord, nullptr);
309
310 auto ret = PasteboardUtils::PasteRecord2Text(pasteRecord);
311 ASSERT_EQ(ret, nullptr);
312 }
313
314 /**
315 * @tc.name: PlainText2PasteRecord001
316 * @tc.desc: pasteData is local data.
317 * @tc.type: FUNC
318 * @tc.require:
319 * @tc.author:
320 */
321 HWTEST_F(PasteboardUtilsTest, PlainText2PasteRecord001, TestSize.Level0)
322 {
323 auto data = InitPlainData();
324 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
325 ASSERT_EQ(1, pasteData->GetRecordCount());
326 auto record = pasteData->GetRecordAt(0);
327 auto type = record->GetMimeType();
328 ASSERT_EQ(type, MIMETYPE_TEXT_PLAIN);
329 auto udType = record->GetUDType();
330 ASSERT_EQ(udType, UDMF::UDType::PLAIN_TEXT);
331 auto entries = record->GetEntries();
332 ASSERT_NE(entries.size(), 0);
333 auto entryValue = entries.front()->GetValue();
334 auto link = std::make_shared<UDMF::PlainText>(UDMF::PLAIN_TEXT, entryValue);
335 ASSERT_EQ(link->GetContent(), text_);
336 ASSERT_EQ(link->GetAbstract(), extraText_);
337
338 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
339 ASSERT_EQ(1, newData->GetRecords().size());
340 auto newRecord = newData->GetRecordAt(0);
341 auto newType = newRecord->GetType();
342 ASSERT_EQ(newType, UDMF::PLAIN_TEXT);
343 auto newPlainRecord = static_cast<UDMF::PlainText *>(newRecord.get());
344 auto newPlainText = newPlainRecord->GetContent();
345 auto newAbstract = newPlainRecord->GetAbstract();
346 auto newDetails = newPlainRecord->GetDetails();
347 ASSERT_EQ(newPlainText, text_);
348 ASSERT_EQ(newAbstract, extraText_);
349 ASSERT_EQ(newDetails, details_);
350 auto unifiedProp = newData->GetProperties();
351 ASSERT_EQ(unifiedProp->isRemote, true);
352 }
353
354 /**
355 * @tc.name: PlainText2PasteRecord002
356 * @tc.desc: plainTextRecord is nullptr.
357 * @tc.type: FUNC
358 * @tc.require:
359 * @tc.author:
360 */
361 HWTEST_F(PasteboardUtilsTest, PlainText2PasteRecord002, TestSize.Level0)
362 {
363 std::shared_ptr<UDMF::PlainText> plainTextRecord;
364 auto pasteRecord = PasteboardUtils::PlainText2PasteRecord(plainTextRecord);
365 ASSERT_EQ(pasteRecord, nullptr);
366
367 auto ret = PasteboardUtils::PasteRecord2PlaintText(pasteRecord);
368 ASSERT_EQ(ret, nullptr);
369 }
370
371 /**
372 * @tc.name: Html2PasteRecord001
373 * @tc.desc: pasteData is local data.
374 * @tc.type: FUNC
375 * @tc.require:
376 * @tc.author:
377 */
378 HWTEST_F(PasteboardUtilsTest, Html2PasteRecord001, TestSize.Level0)
379 {
380 auto data = InitHtmlData();
381 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
382 ASSERT_EQ(1, pasteData->GetRecordCount());
383 auto record = pasteData->GetRecordAt(0);
384 auto type = record->GetMimeType();
385 ASSERT_EQ(type, MIMETYPE_TEXT_HTML);
386 auto udType = record->GetUDType();
387 ASSERT_EQ(udType, UDMF::UDType::HTML);
388 auto entries = record->GetEntries();
389 ASSERT_NE(entries.size(), 0);
390 auto entryValue = entries.front()->GetValue();
391 auto link = std::make_shared<UDMF::Html>(UDMF::HTML, entryValue);
392 ASSERT_EQ(link->GetHtmlContent(), text_);
393 ASSERT_EQ(link->GetPlainContent(), extraText_);
394
395 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
396 ASSERT_EQ(1, newData->GetRecords().size());
397 auto newRecord = newData->GetRecordAt(0);
398 auto newType = newRecord->GetType();
399 ASSERT_EQ(newType, UDMF::HTML);
400 auto newPlainRecord = static_cast<UDMF::Html *>(newRecord.get());
401 auto newPlainText = newPlainRecord->GetHtmlContent();
402 auto newAbstract = newPlainRecord->GetPlainContent();
403 auto newDetails = newPlainRecord->GetDetails();
404 ASSERT_EQ(newPlainText, text_);
405 ASSERT_EQ(newAbstract, extraText_);
406 ASSERT_EQ(newDetails, details_);
407 }
408
409 /**
410 * @tc.name: Html2PasteRecord002
411 * @tc.desc: htmlRecord is nullptr.
412 * @tc.type: FUNC
413 * @tc.require:
414 * @tc.author:
415 */
416 HWTEST_F(PasteboardUtilsTest, Html2PasteRecord002, TestSize.Level0)
417 {
418 std::shared_ptr<UDMF::Html> htmlRecord;
419 auto pasteRecord = PasteboardUtils::Html2PasteRecord(htmlRecord);
420 ASSERT_EQ(pasteRecord, nullptr);
421
422 auto ret = PasteboardUtils::PasteRecord2Html(pasteRecord);
423 ASSERT_EQ(ret, nullptr);
424 }
425
426 /**
427 * @tc.name: Link2PasteRecord001
428 * @tc.desc: pasteData is local data.
429 * @tc.type: FUNC
430 * @tc.require:
431 * @tc.author:
432 */
433 HWTEST_F(PasteboardUtilsTest, Link2PasteRecord001, TestSize.Level0)
434 {
435 auto data = InitLinkData();
436 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
437 ASSERT_EQ(1, pasteData->GetRecordCount());
438 auto record = pasteData->GetRecordAt(0);
439 auto type = record->GetMimeType();
440 ASSERT_EQ(type, MIMETYPE_TEXT_PLAIN);
441 auto udType = record->GetUDType();
442 ASSERT_EQ(udType, UDMF::UDType::HYPERLINK);
443 auto entries = record->GetEntries();
444 ASSERT_NE(entries.size(), 0);
445 auto entryValue = entries.front()->GetValue();
446 auto link = std::make_shared<UDMF::Link>(UDMF::HYPERLINK, entryValue);
447 ASSERT_EQ(link->GetUrl(), text_);
448 ASSERT_EQ(link->GetDescription(), extraText_);
449
450 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
451 ASSERT_EQ(1, newData->GetRecords().size());
452 auto newRecord = newData->GetRecordAt(0);
453 auto newType = newRecord->GetType();
454 ASSERT_EQ(newType, UDMF::HYPERLINK);
455 auto newPlainRecord = static_cast<UDMF::Link *>(newRecord.get());
456 auto newUrl = newPlainRecord->GetUrl();
457 auto newDescription = newPlainRecord->GetDescription();
458 auto newDetails = newPlainRecord->GetDetails();
459 ASSERT_EQ(newUrl, text_);
460 ASSERT_EQ(newDescription, extraText_);
461 ASSERT_EQ(newDetails, details_);
462 }
463
464 /**
465 * @tc.name: Link2PasteRecord002
466 * @tc.desc: linkRecord is nullptr.
467 * @tc.type: FUNC
468 * @tc.require:
469 * @tc.author:
470 */
471 HWTEST_F(PasteboardUtilsTest, Link2PasteRecord002, TestSize.Level0)
472 {
473 std::shared_ptr<UDMF::Link> linkRecord;
474 auto pasteRecord = PasteboardUtils::Link2PasteRecord(linkRecord);
475 ASSERT_EQ(pasteRecord, nullptr);
476
477 auto ret = PasteboardUtils::PasteRecord2Link(pasteRecord);
478 ASSERT_EQ(ret, nullptr);
479 }
480
481 /**
482 * @tc.name: Want2PasteRecord001
483 * @tc.desc: pasteData is local data.
484 * @tc.type: FUNC
485 * @tc.require:
486 * @tc.author:
487 */
488 HWTEST_F(PasteboardUtilsTest, Want2PasteRecord001, TestSize.Level0)
489 {
490 auto data = InitWantData();
491 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
492 ASSERT_EQ(1, pasteData->GetRecordCount());
493 auto record = pasteData->GetRecordAt(0);
494 auto type = record->GetMimeType();
495 ASSERT_EQ(type, MIMETYPE_TEXT_WANT);
496 auto udType = record->GetUDType();
497 ASSERT_EQ(udType, int32_t(UDMF::UDType::OPENHARMONY_WANT));
498 auto want1 = record->GetWant();
499 int32_t idValue1 = want1->GetIntParam("id", 0);
500 ASSERT_EQ(idValue1, 123);
501
502 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
503 ASSERT_EQ(1, newData->GetRecords().size());
504 auto newRecord = newData->GetRecordAt(0);
505 auto newType = newRecord->GetType();
506 ASSERT_EQ(newType, UDMF::OPENHARMONY_WANT);
507 auto recordValue = newRecord->GetValue();
508 auto wantValue = std::get_if<std::shared_ptr<OHOS::AAFwk::Want>>(&recordValue);
509 ASSERT_NE(wantValue, nullptr);
510 int32_t idValue2 = (*(wantValue))->GetIntParam("id", 0);
511 ASSERT_EQ(idValue2, 123);
512 }
513
514 /**
515 * @tc.name: Want2PasteRecord002
516 * @tc.desc: wantRecord is nullptr.
517 * @tc.type: FUNC
518 * @tc.require:
519 * @tc.author:
520 */
521 HWTEST_F(PasteboardUtilsTest, Want2PasteRecord002, TestSize.Level0)
522 {
523 std::shared_ptr<UDMF::UnifiedRecord> wantRecord;
524 auto pasteRecord = PasteboardUtils::Want2PasteRecord(wantRecord);
525 ASSERT_EQ(pasteRecord, nullptr);
526
527 auto ret = PasteboardUtils::PasteRecord2Want(pasteRecord);
528 ASSERT_EQ(ret, nullptr);
529 }
530
531 /**
532 * @tc.name: File2PasteRecord001
533 * @tc.desc: pasteData is local data.
534 * @tc.type: FUNC
535 * @tc.require:
536 * @tc.author:
537 */
538 HWTEST_F(PasteboardUtilsTest, File2PasteRecord001, TestSize.Level0)
539 {
540 auto data = InitFileData();
541 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
542 ASSERT_EQ(1, pasteData->GetRecordCount());
543 auto record = pasteData->GetRecordAt(0);
544 auto type = record->GetMimeType();
545 ASSERT_EQ(type, MIMETYPE_TEXT_URI);
546 auto udType = record->GetUDType();
547 ASSERT_EQ(udType, UDMF::UDType::FILE);
548 auto uri1 = record->GetUriV0()->ToString();
549 ASSERT_EQ(uri1, uri_);
550 auto details1 = record->GetDetails();
551 ASSERT_EQ(*details1, details_);
552
553 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
554 ASSERT_EQ(1, newData->GetRecords().size());
555 auto newRecord = newData->GetRecordAt(0);
556 auto newType = newRecord->GetType();
557 ASSERT_EQ(newType, UDMF::FILE);
558 auto newFileRecord = static_cast<UDMF::File *>(newRecord.get());
559 auto newDetails = newFileRecord->GetDetails();
560 ASSERT_EQ(newDetails, details_);
561 auto uri2 = newFileRecord->GetUri();
562 ASSERT_EQ(uri2, uri_);
563 }
564
565 /**
566 * @tc.name: File2PasteRecord002
567 * @tc.desc: fileRecord is nullptr.
568 * @tc.type: FUNC
569 * @tc.require:
570 * @tc.author:
571 */
572 HWTEST_F(PasteboardUtilsTest, File2PasteRecord002, TestSize.Level0)
573 {
574 std::shared_ptr<UDMF::File> fileRecord;
575 auto pasteRecord = PasteboardUtils::File2PasteRecord(fileRecord);
576 ASSERT_EQ(pasteRecord, nullptr);
577
578 auto ret = PasteboardUtils::PasteRecord2File(pasteRecord);
579 ASSERT_EQ(ret, nullptr);
580 }
581
582 /**
583 * @tc.name: Image2PasteRecord001
584 * @tc.desc: pasteData is local data.
585 * @tc.type: FUNC
586 * @tc.require:
587 * @tc.author:
588 */
589 HWTEST_F(PasteboardUtilsTest, Image2PasteRecord001, TestSize.Level0)
590 {
591 auto data = InitImageData();
592 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
593 ASSERT_EQ(1, pasteData->GetRecordCount());
594 auto record = pasteData->GetRecordAt(0);
595 auto type = record->GetMimeType();
596 ASSERT_EQ(type, MIMETYPE_TEXT_URI);
597 auto udType = record->GetUDType();
598 ASSERT_EQ(udType, UDMF::UDType::IMAGE);
599 auto uri1 = record->GetUriV0()->ToString();
600 ASSERT_EQ(uri1, uri_);
601 auto details1 = record->GetDetails();
602 ASSERT_EQ(*details1, details_);
603
604 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
605 ASSERT_EQ(1, newData->GetRecords().size());
606 auto newRecord = newData->GetRecordAt(0);
607 auto newType = newRecord->GetType();
608 ASSERT_EQ(newType, UDMF::IMAGE);
609 auto newImageRecord = static_cast<UDMF::Image *>(newRecord.get());
610 auto newDetails = newImageRecord->GetDetails();
611 ASSERT_EQ(newDetails, details_);
612 auto uri2 = newImageRecord->GetUri();
613 ASSERT_EQ(uri2, uri_);
614 }
615
616 /**
617 * @tc.name: Image2PasteRecord002
618 * @tc.desc: imageRecord is nullptr.
619 * @tc.type: FUNC
620 * @tc.require:
621 * @tc.author:
622 */
623 HWTEST_F(PasteboardUtilsTest, Image2PasteRecord002, TestSize.Level0)
624 {
625 std::shared_ptr<UDMF::Image> imageRecord;
626 auto pasteRecord = PasteboardUtils::Image2PasteRecord(imageRecord);
627 ASSERT_EQ(pasteRecord, nullptr);
628
629 auto ret = PasteboardUtils::PasteRecord2Image(pasteRecord);
630 ASSERT_EQ(ret, nullptr);
631 }
632
633 /**
634 * @tc.name: Audio2PasteRecord001
635 * @tc.desc: pasteData is local data.
636 * @tc.type: FUNC
637 * @tc.require:
638 * @tc.author:
639 */
640 HWTEST_F(PasteboardUtilsTest, Audio2PasteRecord001, TestSize.Level0)
641 {
642 auto data = InitAudioData();
643 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
644 ASSERT_EQ(1, pasteData->GetRecordCount());
645 auto record = pasteData->GetRecordAt(0);
646 auto type = record->GetMimeType();
647 ASSERT_EQ(type, MIMETYPE_TEXT_URI);
648 auto udType = record->GetUDType();
649 ASSERT_EQ(udType, UDMF::UDType::AUDIO);
650 auto uri1 = record->GetUriV0()->ToString();
651 ASSERT_EQ(uri1, uri_);
652 auto details1 = record->GetDetails();
653 ASSERT_EQ(*details1, details_);
654
655 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
656 ASSERT_EQ(1, newData->GetRecords().size());
657 auto newRecord = newData->GetRecordAt(0);
658 auto newType = newRecord->GetType();
659 ASSERT_EQ(newType, UDMF::AUDIO);
660 auto newAudioRecord = static_cast<UDMF::Audio *>(newRecord.get());
661 auto newDetails = newAudioRecord->GetDetails();
662 ASSERT_EQ(newDetails, details_);
663 auto uri2 = newAudioRecord->GetUri();
664 ASSERT_EQ(uri2, uri_);
665 }
666
667 /**
668 * @tc.name: Audio2PasteRecord002
669 * @tc.desc: audioRecord is nullptr.
670 * @tc.type: FUNC
671 * @tc.require:
672 * @tc.author:
673 */
674 HWTEST_F(PasteboardUtilsTest, Audio2PasteRecord002, TestSize.Level0)
675 {
676 std::shared_ptr<UDMF::Audio> audioRecord;
677 auto pasteRecord = PasteboardUtils::Audio2PasteRecord(audioRecord);
678 ASSERT_EQ(pasteRecord, nullptr);
679
680 auto ret = PasteboardUtils::PasteRecord2Audio(pasteRecord);
681 ASSERT_EQ(ret, nullptr);
682 }
683
684 /**
685 * @tc.name: Video2PasteRecord001
686 * @tc.desc: pasteData is local data.
687 * @tc.type: FUNC
688 * @tc.require:
689 * @tc.author:
690 */
691 HWTEST_F(PasteboardUtilsTest, Video2PasteRecord001, TestSize.Level0)
692 {
693 auto data = InitVideoData();
694 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
695 ASSERT_EQ(1, pasteData->GetRecordCount());
696 auto record = pasteData->GetRecordAt(0);
697 auto type = record->GetMimeType();
698 ASSERT_EQ(type, MIMETYPE_TEXT_URI);
699 auto udType = record->GetUDType();
700 ASSERT_EQ(udType, UDMF::UDType::VIDEO);
701 auto uri1 = record->GetUriV0()->ToString();
702 ASSERT_EQ(uri1, uri_);
703 auto details1 = record->GetDetails();
704 ASSERT_EQ(*details1, details_);
705
706 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
707 ASSERT_EQ(1, newData->GetRecords().size());
708 auto newRecord = newData->GetRecordAt(0);
709 auto newType = newRecord->GetType();
710 ASSERT_EQ(newType, UDMF::VIDEO);
711 auto newVideoRecord = static_cast<UDMF::Video *>(newRecord.get());
712 auto newDetails = newVideoRecord->GetDetails();
713 ASSERT_EQ(newDetails, details_);
714 auto uri2 = newVideoRecord->GetUri();
715 ASSERT_EQ(uri2, uri_);
716 }
717
718 /**
719 * @tc.name: Video2PasteRecord002
720 * @tc.desc: videoRecord is nullptr.
721 * @tc.type: FUNC
722 * @tc.require:
723 * @tc.author:
724 */
725 HWTEST_F(PasteboardUtilsTest, Video2PasteRecord002, TestSize.Level0)
726 {
727 std::shared_ptr<UDMF::Video> videoRecord;
728 auto pasteRecord = PasteboardUtils::Video2PasteRecord(videoRecord);
729 ASSERT_EQ(pasteRecord, nullptr);
730
731 auto ret = PasteboardUtils::PasteRecord2Video(pasteRecord);
732 ASSERT_EQ(ret, nullptr);
733 }
734
735 /**
736 * @tc.name: Folder2PasteRecord001
737 * @tc.desc: pasteData is local data.
738 * @tc.type: FUNC
739 * @tc.require:
740 * @tc.author:
741 */
742 HWTEST_F(PasteboardUtilsTest, Folder2PasteRecord001, TestSize.Level0)
743 {
744 auto data = InitFolderData();
745 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
746 ASSERT_EQ(1, pasteData->GetRecordCount());
747 auto record = pasteData->GetRecordAt(0);
748 auto type = record->GetMimeType();
749 ASSERT_EQ(type, MIMETYPE_TEXT_URI);
750 auto udType = record->GetUDType();
751 ASSERT_EQ(udType, UDMF::UDType::FOLDER);
752 auto uri1 = record->GetUriV0()->ToString();
753 ASSERT_EQ(uri1, uri_);
754 auto details1 = record->GetDetails();
755 ASSERT_EQ(*details1, details_);
756
757 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
758 ASSERT_EQ(1, newData->GetRecords().size());
759 auto newRecord = newData->GetRecordAt(0);
760 auto newType = newRecord->GetType();
761 ASSERT_EQ(newType, UDMF::FOLDER);
762 auto newFolderRecord = static_cast<UDMF::Folder *>(newRecord.get());
763 auto newDetails = newFolderRecord->GetDetails();
764 ASSERT_EQ(newDetails, details_);
765 auto uri2 = newFolderRecord->GetUri();
766 ASSERT_EQ(uri2, uri_);
767 }
768
769 /**
770 * @tc.name: Folder2PasteRecord002
771 * @tc.desc: folderRecord is nullptr.
772 * @tc.type: FUNC
773 * @tc.require:
774 * @tc.author:
775 */
776 HWTEST_F(PasteboardUtilsTest, Folder2PasteRecord002, TestSize.Level0)
777 {
778 std::shared_ptr<UDMF::Folder> folderRecord;
779 auto pasteRecord = PasteboardUtils::Folder2PasteRecord(folderRecord);
780 ASSERT_EQ(pasteRecord, nullptr);
781
782 auto ret = PasteboardUtils::PasteRecord2Folder(pasteRecord);
783 ASSERT_EQ(ret, nullptr);
784 }
785
786 /**
787 * @tc.name: SystemDefined2PasteRecord001
788 * @tc.desc: pasteData is local data.
789 * @tc.type: FUNC
790 * @tc.require:
791 * @tc.author:
792 */
793 HWTEST_F(PasteboardUtilsTest, SystemDefined2PasteRecord001, TestSize.Level0)
794 {
795 auto data = InitSystemRecordData();
796 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
797 ASSERT_EQ(1, pasteData->GetRecordCount());
798 auto record = pasteData->GetRecordAt(0);
799 auto type = record->GetMimeType();
800 ASSERT_EQ(type, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_RECORD));
801 auto udType = record->GetUDType();
802 ASSERT_EQ(udType, UDMF::SYSTEM_DEFINED_RECORD);
803 auto details1 = record->GetDetails();
804 ASSERT_EQ(*details1, details_);
805
806 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
807 ASSERT_EQ(1, newData->GetRecords().size());
808 auto newRecord = newData->GetRecordAt(0);
809 auto newType = newRecord->GetType();
810 ASSERT_EQ(newType, UDMF::SYSTEM_DEFINED_RECORD);
811 auto newSystemRecord = static_cast<UDMF::SystemDefinedRecord *>(newRecord.get());
812 ASSERT_EQ(newSystemRecord->GetDetails(), details_);
813 }
814
815 /**
816 * @tc.name: SystemDefined2PasteRecord002
817 * @tc.desc: systemRecord is nullptr.
818 * @tc.type: FUNC
819 * @tc.require:
820 * @tc.author:
821 */
822 HWTEST_F(PasteboardUtilsTest, SystemDefined2PasteRecord002, TestSize.Level0)
823 {
824 std::shared_ptr<UDMF::SystemDefinedRecord> systemRecord;
825 auto pasteRecord = PasteboardUtils::SystemDefined2PasteRecord(systemRecord);
826 ASSERT_EQ(pasteRecord, nullptr);
827
828 auto ret = PasteboardUtils::PasteRecord2SystemDefined(pasteRecord);
829 ASSERT_EQ(ret, nullptr);
830 }
831
832 /**
833 * @tc.name: AppItem2PasteRecord001
834 * @tc.desc: pasteData is local data.
835 * @tc.type: FUNC
836 * @tc.require:
837 * @tc.author:
838 */
839 HWTEST_F(PasteboardUtilsTest, AppItem2PasteRecord001, TestSize.Level0)
840 {
841 auto data = InitSystemAppItemData();
842 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
843 ASSERT_EQ(1, pasteData->GetRecordCount());
844 auto record = pasteData->GetRecordAt(0);
845 auto type = record->GetMimeType();
846 ASSERT_EQ(type, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_APP_ITEM));
847 auto udType = record->GetUDType();
848 ASSERT_EQ(udType, UDMF::SYSTEM_DEFINED_APP_ITEM);
849 auto details1 = record->GetDetails();
850 ASSERT_NE(details1, nullptr);
851 ASSERT_EQ(*details1, details_);
852 auto entries = record->GetEntries();
853 ASSERT_NE(entries.size(), 0);
854 auto entryValue = entries.front()->GetValue();
855 auto newAppItem1 = std::make_shared<UDMF::SystemDefinedAppItem>(UDMF::SYSTEM_DEFINED_APP_ITEM, entryValue);
856 ASSERT_EQ(newAppItem1->GetAppId(), "appId");
857 ASSERT_EQ(newAppItem1->GetAppIconId(), "appIconId");
858 ASSERT_EQ(newAppItem1->GetAppName(), "appName");
859 ASSERT_EQ(newAppItem1->GetAppLabelId(), "appLabelId");
860 ASSERT_EQ(newAppItem1->GetBundleName(), "bundleName");
861 ASSERT_EQ(newAppItem1->GetAbilityName(), "abilityName");
862
863 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
864 ASSERT_EQ(1, newData->GetRecords().size());
865 auto newRecord = newData->GetRecordAt(0);
866 auto newType = newRecord->GetType();
867 ASSERT_EQ(newType, UDMF::SYSTEM_DEFINED_APP_ITEM);
868 auto newAppItem = static_cast<UDMF::SystemDefinedAppItem *>(newRecord.get());
869 ASSERT_EQ(newAppItem->GetAppId(), "appId");
870 ASSERT_EQ(newAppItem->GetAppIconId(), "appIconId");
871 ASSERT_EQ(newAppItem->GetAppName(), "appName");
872 ASSERT_EQ(newAppItem->GetAppLabelId(), "appLabelId");
873 ASSERT_EQ(newAppItem->GetBundleName(), "bundleName");
874 ASSERT_EQ(newAppItem->GetAbilityName(), "abilityName");
875 ASSERT_EQ(newAppItem->GetDetails(), details_);
876 }
877
878 /**
879 * @tc.name: AppItem2PasteRecord002
880 * @tc.desc: systemDefinedAppItem is nullptr.
881 * @tc.type: FUNC
882 * @tc.require:
883 * @tc.author:
884 */
885 HWTEST_F(PasteboardUtilsTest, AppItem2PasteRecord002, TestSize.Level0)
886 {
887 std::shared_ptr<UDMF::SystemDefinedAppItem> systemDefinedAppItem;
888 auto pasteRecord = PasteboardUtils::AppItem2PasteRecord(systemDefinedAppItem);
889 ASSERT_EQ(pasteRecord, nullptr);
890
891 auto ret = PasteboardUtils::PasteRecord2AppItem(pasteRecord);
892 ASSERT_EQ(ret, nullptr);
893 }
894
895 /**
896 * @tc.name: Form2PasteRecord001
897 * @tc.desc: pasteData is local data.
898 * @tc.type: FUNC
899 * @tc.require:
900 * @tc.author:
901 */
902 HWTEST_F(PasteboardUtilsTest, Form2PasteRecord001, TestSize.Level0)
903 {
904 auto data = InitSystemFormData();
905 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
906 ASSERT_EQ(1, pasteData->GetRecordCount());
907 auto record = pasteData->GetRecordAt(0);
908 auto type = record->GetMimeType();
909 ASSERT_EQ(type, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_FORM));
910 auto udType = record->GetUDType();
911 ASSERT_EQ(udType, UDMF::SYSTEM_DEFINED_FORM);
912 auto details1 = record->GetDetails();
913 auto content = *(record->GetSystemDefinedContent());
914 ASSERT_EQ(*details1, details_);
915 auto formId1 = std::get<std::int32_t>(content["formId"]);
916 auto formName1 = std::get<std::string>(content["formName"]);
917 auto module1 = std::get<std::string>(content["module"]);
918 auto bundleName1 = std::get<std::string>(content["bundleName"]);
919 auto abilityName1 = std::get<std::string>(content["abilityName"]);
920 ASSERT_EQ(1, formId1);
921 ASSERT_EQ("formName", formName1);
922 ASSERT_EQ("module", module1);
923 ASSERT_EQ("bundleName", bundleName1);
924 ASSERT_EQ("abilityName", abilityName1);
925
926 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
927 ASSERT_EQ(1, newData->GetRecords().size());
928 auto newRecord = newData->GetRecordAt(0);
929 auto newType = newRecord->GetType();
930 ASSERT_EQ(newType, UDMF::SYSTEM_DEFINED_FORM);
931 auto newForm = static_cast<UDMF::SystemDefinedForm *>(newRecord.get());
932 ASSERT_EQ(newForm->GetFormId(), formId1);
933 ASSERT_EQ(newForm->GetFormName(), formName1);
934 ASSERT_EQ(newForm->GetModule(), module1);
935 ASSERT_EQ(newForm->GetBundleName(), bundleName1);
936 ASSERT_EQ(newForm->GetAbilityName(), abilityName1);
937 ASSERT_EQ(newForm->GetDetails(), details_);
938 }
939
940 /**
941 * @tc.name: Form2PasteRecord002
942 * @tc.desc: form is nullptr.
943 * @tc.type: FUNC
944 * @tc.require:
945 * @tc.author:
946 */
947 HWTEST_F(PasteboardUtilsTest, Form2PasteRecord002, TestSize.Level0)
948 {
949 std::shared_ptr<UDMF::SystemDefinedForm> form;
950 auto pasteRecord = PasteboardUtils::Form2PasteRecord(form);
951 ASSERT_EQ(pasteRecord, nullptr);
952
953 auto ret = PasteboardUtils::PasteRecord2Form(pasteRecord);
954 ASSERT_EQ(ret, nullptr);
955 }
956
957 /**
958 * @tc.name: PixelMap2PasteRecord001
959 * @tc.desc: pasteData is local data.
960 * @tc.type: FUNC
961 * @tc.require:
962 * @tc.author:
963 */
964 HWTEST_F(PasteboardUtilsTest, PixelMap2PasteRecord001, TestSize.Level0)
965 {
966 auto data = InitSystemPixelMapData();
967 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
968 ASSERT_EQ(1, pasteData->GetRecordCount());
969 auto record = pasteData->GetRecordAt(0);
970 auto type = record->GetMimeType();
971 ASSERT_EQ(type, MIMETYPE_PIXELMAP);
972 auto udType = record->GetUDType();
973 ASSERT_EQ(udType, int32_t(UDMF::UDType::SYSTEM_DEFINED_PIXEL_MAP));
974 auto newPixelMap = record->GetPixelMapV0();
975 ASSERT_TRUE(newPixelMap != nullptr);
976 ImageInfo imageInfo = {};
977 newPixelMap->GetImageInfo(imageInfo);
978 ASSERT_TRUE(imageInfo.size.height == 7);
979 ASSERT_TRUE(imageInfo.size.width == 5);
980 ASSERT_TRUE(imageInfo.pixelFormat == PixelFormat::ARGB_8888);
981
982 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
983 ASSERT_EQ(1, newData->GetRecords().size());
984 auto newRecord = newData->GetRecordAt(0);
985 auto newType = newRecord->GetType();
986 ASSERT_EQ(newType, UDMF::SYSTEM_DEFINED_PIXEL_MAP);
987 auto recordValue = newRecord->GetValue();
988 auto newPixelMap1 = std::get_if<std::shared_ptr<OHOS::Media::PixelMap>>(&recordValue);
989 ASSERT_NE(newPixelMap1, nullptr);
990 ImageInfo imageInfo1 = {};
991 (*newPixelMap1)->GetImageInfo(imageInfo1);
992 ASSERT_TRUE(imageInfo1.size.height == imageInfo.size.height);
993 ASSERT_TRUE(imageInfo1.size.width == imageInfo.size.width);
994 ASSERT_TRUE(imageInfo1.pixelFormat == imageInfo.pixelFormat);
995 }
996
997 /**
998 * @tc.name: PixelMap2PasteRecord002
999 * @tc.desc: pixelMapRecord is nullptr.
1000 * @tc.type: FUNC
1001 * @tc.require:
1002 * @tc.author:
1003 */
1004 HWTEST_F(PasteboardUtilsTest, PixelMap2PasteRecord002, TestSize.Level0)
1005 {
1006 std::shared_ptr<UDMF::UnifiedRecord> pixelMapRecord;
1007 auto pasteRecord = PasteboardUtils::PixelMap2PasteRecord(pixelMapRecord);
1008 ASSERT_EQ(pasteRecord, nullptr);
1009
1010 auto ret = PasteboardUtils::PasteRecord2PixelMap(pasteRecord);
1011 ASSERT_EQ(ret, nullptr);
1012 }
1013
1014 /**
1015 * @tc.name: AppDefined2PasteRecord001
1016 * @tc.desc: pasteData is local data.
1017 * @tc.type: FUNC
1018 * @tc.require:
1019 * @tc.author:
1020 */
1021 HWTEST_F(PasteboardUtilsTest, AppDefined2PasteRecord001, TestSize.Level0)
1022 {
1023 auto data = InitAppDefinedData();
1024 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
1025 ASSERT_EQ(1, pasteData->GetRecordCount());
1026 auto record = pasteData->GetRecordAt(0);
1027 auto type = record->GetMimeType();
1028 ASSERT_EQ(type, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::APPLICATION_DEFINED_RECORD));
1029 auto udType = record->GetUDType();
1030 ASSERT_EQ(udType, UDMF::APPLICATION_DEFINED_RECORD);
1031 auto items = record->GetCustomData()->GetItemData();
1032 std::map<std::string, std::vector<uint8_t>> customData {
1033 {type, rawData_}
1034 };
1035 ASSERT_EQ(items, customData);
1036
1037 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
1038 ASSERT_EQ(1, newData->GetRecords().size());
1039 auto newRecord = newData->GetRecordAt(0);
1040 auto newType = newRecord->GetType();
1041 ASSERT_EQ(newType, UDMF::APPLICATION_DEFINED_RECORD);
1042 auto newSystemRecord = static_cast<UDMF::ApplicationDefinedRecord *>(newRecord.get());
1043 ASSERT_EQ(newSystemRecord->GetRawData(), rawData_);
1044 }
1045
1046 /**
1047 * @tc.name: AppDefined2PasteRecord002
1048 * @tc.desc: appRecord is nullptr.
1049 * @tc.type: FUNC
1050 * @tc.require:
1051 * @tc.author:
1052 */
1053 HWTEST_F(PasteboardUtilsTest, AppDefined2PasteRecord002, TestSize.Level0)
1054 {
1055 std::shared_ptr<UDMF::ApplicationDefinedRecord> appRecord;
1056 auto pasteRecord = PasteboardUtils::AppDefined2PasteRecord(appRecord);
1057 ASSERT_EQ(pasteRecord, nullptr);
1058
1059 auto ret = PasteboardUtils::Custom2AppDefined(pasteRecord);
1060 ASSERT_EQ(ret.size(), 0);
1061 }
1062
1063 /**
1064 * @tc.name: ConvertTest001
1065 * @tc.desc: Traverse UDType.
1066 * @tc.type: FUNC
1067 * @tc.require:
1068 * @tc.author:
1069 */
1070 HWTEST_F(PasteboardUtilsTest, ConvertTest001, TestSize.Level0)
1071 {
1072 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UDType::PLAIN_TEXT), MIMETYPE_TEXT_PLAIN);
1073 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UDType::HTML), MIMETYPE_TEXT_HTML);
1074 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UDType::FILE_URI), MIMETYPE_TEXT_URI);
1075 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UDType::SYSTEM_DEFINED_PIXEL_MAP), MIMETYPE_PIXELMAP);
1076 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UDType::OPENHARMONY_WANT), MIMETYPE_TEXT_WANT);
1077 }
1078
1079 /**
1080 * @tc.name: ConvertTest002
1081 * @tc.desc: Traverse MIMEType.
1082 * @tc.type: FUNC
1083 * @tc.require:
1084 * @tc.author:
1085 */
1086 HWTEST_F(PasteboardUtilsTest, ConvertTest002, TestSize.Level0)
1087 {
1088 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UD_BUTT, MIMETYPE_TEXT_URI), UDMF::FILE);
1089 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UD_BUTT, MIMETYPE_TEXT_PLAIN), UDMF::PLAIN_TEXT);
1090 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UD_BUTT, MIMETYPE_TEXT_HTML), UDMF::HTML);
1091 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UD_BUTT, MIMETYPE_TEXT_WANT), UDMF::OPENHARMONY_WANT);
1092 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UD_BUTT, MIMETYPE_PIXELMAP), UDMF::SYSTEM_DEFINED_PIXEL_MAP);
1093 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UD_BUTT, text_), UDMF::UD_BUTT);
1094 std::string mimeType = "general.jpeg-2000";
1095 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UD_BUTT, mimeType), UDMF::JPEG2000);
1096 }
1097
1098 /**
1099 * @tc.name: ConvertShareOptionTest001
1100 * @tc.desc: Test Convert function when properties.shareOptions is UDMF::IN_APP
1101 * @tc.type: FUNC
1102 * @tc.require:
1103 */
1104 HWTEST_F(PasteboardUtilsTest, ConvertShareOptionTest001, TestSize.Level0)
1105 {
1106 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest001 start");
1107 UDMF::UnifiedDataProperties properties;
1108 PasteDataProperty result;
1109
1110 properties.shareOptions = UDMF::IN_APP;
1111 result.shareOption = LocalDevice;
1112 result = PasteboardUtils::Convert(properties);
1113 EXPECT_EQ(result.shareOption, InApp);
1114 result.shareOption = CrossDevice;
1115 result = PasteboardUtils::Convert(properties);
1116 EXPECT_EQ(result.shareOption, InApp);
1117 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest001 end");
1118 }
1119
1120 /**
1121 * @tc.name: ConvertShareOptionTest002
1122 * @tc.desc: Test Convert function when properties.shareOptions is UDMF::CROSS_APP
1123 * @tc.type: FUNC
1124 * @tc.require:
1125 */
1126 HWTEST_F(PasteboardUtilsTest, ConvertShareOptionTest002, TestSize.Level0)
1127 {
1128 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest002 start");
1129 UDMF::UnifiedDataProperties properties;
1130 PasteDataProperty result;
1131
1132 properties.shareOptions = UDMF::CROSS_APP;
1133 result.shareOption = InApp;
1134 result = PasteboardUtils::Convert(properties);
1135 EXPECT_EQ(result.shareOption, LocalDevice);
1136 result.shareOption = CrossDevice;
1137 result = PasteboardUtils::Convert(properties);
1138 EXPECT_EQ(result.shareOption, LocalDevice);
1139
1140 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest002 end");
1141 }
1142
1143 /**
1144 * @tc.name: ConvertShareOptionTest003
1145 * @tc.desc: Test Convert function when properties.shareOptions is UDMF::CROSS_DEVICE
1146 * @tc.type: FUNC
1147 * @tc.require:
1148 */
1149 HWTEST_F(PasteboardUtilsTest, ConvertShareOptionTest003, TestSize.Level0)
1150 {
1151 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest003 start");
1152 UDMF::UnifiedDataProperties properties;
1153 PasteDataProperty result;
1154
1155 properties.shareOptions = UDMF::CROSS_DEVICE;
1156 result.shareOption = InApp;
1157 result = PasteboardUtils::Convert(properties);
1158 EXPECT_EQ(result.shareOption, CrossDevice);
1159 result.shareOption = LocalDevice;
1160 result = PasteboardUtils::Convert(properties);
1161 EXPECT_EQ(result.shareOption, CrossDevice);
1162
1163 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest003 end");
1164 }
1165
1166 /**
1167 * @tc.name: ConvertShareOptionTest004
1168 * @tc.desc: Test Convert function when properties.shareOptions is UDMF::SHARE_OPTIONS_BUTT
1169 * @tc.type: FUNC
1170 * @tc.require:
1171 */
1172 HWTEST_F(PasteboardUtilsTest, ConvertShareOptionTest004, TestSize.Level0)
1173 {
1174 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest004 start");
1175 UDMF::UnifiedDataProperties properties;
1176 PasteDataProperty result;
1177
1178 properties.shareOptions = UDMF::SHARE_OPTIONS_BUTT;
1179 result.shareOption = InApp;
1180 result = PasteboardUtils::Convert(properties);
1181 EXPECT_EQ(result.shareOption, CrossDevice);
1182 result.shareOption = LocalDevice;
1183 result = PasteboardUtils::Convert(properties);
1184 EXPECT_EQ(result.shareOption, CrossDevice);
1185
1186 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest004 end");
1187 }
1188
1189 /**
1190 * @tc.name: ConvertShareOptionTest005
1191 * @tc.desc: Test Convert function when properties.shareOption is InApp
1192 * @tc.type: FUNC
1193 * @tc.require:
1194 */
1195 HWTEST_F(PasteboardUtilsTest, ConvertShareOptionTest005, TestSize.Level0)
1196 {
1197 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest005 start");
1198 PasteDataProperty properties;
1199 std::shared_ptr<UDMF::UnifiedDataProperties> result = std::make_shared<UDMF::UnifiedDataProperties>();
1200
1201 properties.shareOption = InApp;
1202 result->shareOptions = UDMF::CROSS_APP;
1203 result = PasteboardUtils::Convert(properties);
1204 EXPECT_EQ(result->shareOptions, UDMF::IN_APP);
1205 result->shareOptions = UDMF::CROSS_DEVICE;
1206 result = PasteboardUtils::Convert(properties);
1207 EXPECT_EQ(result->shareOptions, UDMF::IN_APP);
1208
1209 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest005 end");
1210 }
1211
1212 /**
1213 * @tc.name: ConvertShareOptionTest006
1214 * @tc.desc: Test Convert function when properties.shareOption is LocalDevice
1215 * @tc.type: FUNC
1216 * @tc.require:
1217 */
1218 HWTEST_F(PasteboardUtilsTest, ConvertShareOptionTest006, TestSize.Level0)
1219 {
1220 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest006 start");
1221 PasteDataProperty properties;
1222 std::shared_ptr<UDMF::UnifiedDataProperties> result = std::make_shared<UDMF::UnifiedDataProperties>();
1223
1224 properties.shareOption = LocalDevice;
1225 result->shareOptions = UDMF::IN_APP;
1226 result = PasteboardUtils::Convert(properties);
1227 EXPECT_EQ(result->shareOptions, UDMF::CROSS_APP);
1228 result->shareOptions = UDMF::CROSS_DEVICE;
1229 result = PasteboardUtils::Convert(properties);
1230 EXPECT_EQ(result->shareOptions, UDMF::CROSS_APP);
1231
1232 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest006 end");
1233 }
1234
1235 /**
1236 * @tc.name: ConvertShareOptionTest007
1237 * @tc.desc: Test Convert function when properties.shareOption is CrossDevice
1238 * @tc.type: FUNC
1239 * @tc.require:
1240 */
1241 HWTEST_F(PasteboardUtilsTest, ConvertShareOptionTest007, TestSize.Level0)
1242 {
1243 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest007 start");
1244 PasteDataProperty properties;
1245 std::shared_ptr<UDMF::UnifiedDataProperties> result = std::make_shared<UDMF::UnifiedDataProperties>();
1246
1247 properties.shareOption = CrossDevice;
1248 result->shareOptions = UDMF::IN_APP;
1249 result = PasteboardUtils::Convert(properties);
1250 EXPECT_EQ(result->shareOptions, UDMF::CROSS_DEVICE);
1251 result->shareOptions = UDMF::CROSS_APP;
1252 result = PasteboardUtils::Convert(properties);
1253 EXPECT_EQ(result->shareOptions, UDMF::CROSS_DEVICE);
1254
1255 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest007 end");
1256 }
1257
1258 /**
1259 * @tc.name: DeduplicateVectorTest
1260 * @tc.desc: Remove duplicate value from string vector
1261 * @tc.type: FUNC
1262 * @tc.require:
1263 */
1264 HWTEST_F(PasteboardUtilsTest, DeduplicateVectorTest, TestSize.Level0)
1265 {
1266 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "DeduplicateVectorTest start");
1267 const std::vector<std::string> vec1(3, "test");
1268 const std::vector<std::string> vec2(1, "test");
1269 std::vector<std::string> result = PasteboardUtils::GetInstance().DeduplicateVector(vec1);
1270 EXPECT_EQ(std::equal(result.begin(), result.end(), vec2.begin()), true);
1271 const std::vector<std::string> vec3 = {"a", "b", "c", "a", "b", "c"};
1272 std::vector<std::string> vec4 = {"a", "b", "c"};
1273 result = PasteboardUtils::GetInstance().DeduplicateVector(vec3);
1274 EXPECT_EQ(result.size(), vec4.size());
1275 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "DeduplicateVectorTest end");
1276 }
1277
1278 } // namespace OHOS::MiscServices