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 InitSysteFormData();
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 }
InitSysteFormData()220 UDMF::UnifiedData PasteboardUtilsTest::InitSysteFormData()
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 udmfValue = record->GetUDMFValue();
332 ASSERT_NE(udmfValue, nullptr);
333 auto link = std::make_shared<UDMF::PlainText>(UDMF::PLAIN_TEXT, *udmfValue);
334 ASSERT_EQ(link->GetContent(), text_);
335 ASSERT_EQ(link->GetAbstract(), extraText_);
336
337 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
338 ASSERT_EQ(1, newData->GetRecords().size());
339 auto newRecord = newData->GetRecordAt(0);
340 auto newType = newRecord->GetType();
341 ASSERT_EQ(newType, UDMF::PLAIN_TEXT);
342 auto newPlainRecord = static_cast<UDMF::PlainText *>(newRecord.get());
343 auto newPlainText = newPlainRecord->GetContent();
344 auto newAbstract = newPlainRecord->GetAbstract();
345 auto newDetails = newPlainRecord->GetDetails();
346 ASSERT_EQ(newPlainText, text_);
347 ASSERT_EQ(newAbstract, extraText_);
348 ASSERT_EQ(newDetails, details_);
349 auto unifiedProp = newData->GetProperties();
350 ASSERT_EQ(unifiedProp->isRemote, true);
351 }
352
353 /**
354 * @tc.name: PlainText2PasteRecord002
355 * @tc.desc: plainTextRecord is nullptr.
356 * @tc.type: FUNC
357 * @tc.require:
358 * @tc.author:
359 */
360 HWTEST_F(PasteboardUtilsTest, PlainText2PasteRecord002, TestSize.Level0)
361 {
362 std::shared_ptr<UDMF::PlainText> plainTextRecord;
363 auto pasteRecord = PasteboardUtils::PlainText2PasteRecord(plainTextRecord);
364 ASSERT_EQ(pasteRecord, nullptr);
365
366 auto ret = PasteboardUtils::PasteRecord2PlaintText(pasteRecord);
367 ASSERT_EQ(ret, nullptr);
368 }
369
370 /**
371 * @tc.name: Html2PasteRecord001
372 * @tc.desc: pasteData is local data.
373 * @tc.type: FUNC
374 * @tc.require:
375 * @tc.author:
376 */
377 HWTEST_F(PasteboardUtilsTest, Html2PasteRecord001, TestSize.Level0)
378 {
379 auto data = InitHtmlData();
380 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
381 ASSERT_EQ(1, pasteData->GetRecordCount());
382 auto record = pasteData->GetRecordAt(0);
383 auto type = record->GetMimeType();
384 ASSERT_EQ(type, MIMETYPE_TEXT_HTML);
385 auto udType = record->GetUDType();
386 ASSERT_EQ(udType, UDMF::UDType::HTML);
387 auto udmfValue = record->GetUDMFValue();
388 ASSERT_NE(udmfValue, nullptr);
389 auto link = std::make_shared<UDMF::Html>(UDMF::HTML, *udmfValue);
390 ASSERT_EQ(link->GetHtmlContent(), text_);
391 ASSERT_EQ(link->GetPlainContent(), extraText_);
392
393 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
394 ASSERT_EQ(1, newData->GetRecords().size());
395 auto newRecord = newData->GetRecordAt(0);
396 auto newType = newRecord->GetType();
397 ASSERT_EQ(newType, UDMF::HTML);
398 auto newPlainRecord = static_cast<UDMF::Html *>(newRecord.get());
399 auto newPlainText = newPlainRecord->GetHtmlContent();
400 auto newAbstract = newPlainRecord->GetPlainContent();
401 auto newDetails = newPlainRecord->GetDetails();
402 ASSERT_EQ(newPlainText, text_);
403 ASSERT_EQ(newAbstract, extraText_);
404 ASSERT_EQ(newDetails, details_);
405 }
406
407 /**
408 * @tc.name: Html2PasteRecord002
409 * @tc.desc: htmlRecord is nullptr.
410 * @tc.type: FUNC
411 * @tc.require:
412 * @tc.author:
413 */
414 HWTEST_F(PasteboardUtilsTest, Html2PasteRecord002, TestSize.Level0)
415 {
416 std::shared_ptr<UDMF::Html> htmlRecord;
417 auto pasteRecord = PasteboardUtils::Html2PasteRecord(htmlRecord);
418 ASSERT_EQ(pasteRecord, nullptr);
419
420 auto ret = PasteboardUtils::PasteRecord2Html(pasteRecord);
421 ASSERT_EQ(ret, nullptr);
422 }
423
424 /**
425 * @tc.name: Link2PasteRecord001
426 * @tc.desc: pasteData is local data.
427 * @tc.type: FUNC
428 * @tc.require:
429 * @tc.author:
430 */
431 HWTEST_F(PasteboardUtilsTest, Link2PasteRecord001, TestSize.Level0)
432 {
433 auto data = InitLinkData();
434 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
435 ASSERT_EQ(1, pasteData->GetRecordCount());
436 auto record = pasteData->GetRecordAt(0);
437 auto type = record->GetMimeType();
438 ASSERT_EQ(type, MIMETYPE_TEXT_PLAIN);
439 auto udType = record->GetUDType();
440 ASSERT_EQ(udType, UDMF::UDType::HYPERLINK);
441 auto udmfValue = record->GetUDMFValue();
442 ASSERT_NE(udmfValue, nullptr);
443 auto link = std::make_shared<UDMF::Link>(UDMF::HYPERLINK, *udmfValue);
444 ASSERT_EQ(link->GetUrl(), text_);
445 ASSERT_EQ(link->GetDescription(), extraText_);
446
447 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
448 ASSERT_EQ(1, newData->GetRecords().size());
449 auto newRecord = newData->GetRecordAt(0);
450 auto newType = newRecord->GetType();
451 ASSERT_EQ(newType, UDMF::HYPERLINK);
452 auto newPlainRecord = static_cast<UDMF::Link *>(newRecord.get());
453 auto newUrl = newPlainRecord->GetUrl();
454 auto newDescription = newPlainRecord->GetDescription();
455 auto newDetails = newPlainRecord->GetDetails();
456 ASSERT_EQ(newUrl, text_);
457 ASSERT_EQ(newDescription, extraText_);
458 ASSERT_EQ(newDetails, details_);
459 }
460
461 /**
462 * @tc.name: Link2PasteRecord002
463 * @tc.desc: linkRecord is nullptr.
464 * @tc.type: FUNC
465 * @tc.require:
466 * @tc.author:
467 */
468 HWTEST_F(PasteboardUtilsTest, Link2PasteRecord002, TestSize.Level0)
469 {
470 std::shared_ptr<UDMF::Link> linkRecord;
471 auto pasteRecord = PasteboardUtils::Link2PasteRecord(linkRecord);
472 ASSERT_EQ(pasteRecord, nullptr);
473
474 auto ret = PasteboardUtils::PasteRecord2Link(pasteRecord);
475 ASSERT_EQ(ret, nullptr);
476 }
477
478 /**
479 * @tc.name: Want2PasteRecord001
480 * @tc.desc: pasteData is local data.
481 * @tc.type: FUNC
482 * @tc.require:
483 * @tc.author:
484 */
485 HWTEST_F(PasteboardUtilsTest, Want2PasteRecord001, TestSize.Level0)
486 {
487 auto data = InitWantData();
488 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
489 ASSERT_EQ(1, pasteData->GetRecordCount());
490 auto record = pasteData->GetRecordAt(0);
491 auto type = record->GetMimeType();
492 ASSERT_EQ(type, MIMETYPE_TEXT_WANT);
493 auto udType = record->GetUDType();
494 ASSERT_EQ(udType, int32_t(UDMF::UDType::OPENHARMONY_WANT));
495 auto want1 = record->GetWant();
496 int32_t idValue1 = want1->GetIntParam("id", 0);
497 ASSERT_EQ(idValue1, 123);
498
499 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
500 ASSERT_EQ(1, newData->GetRecords().size());
501 auto newRecord = newData->GetRecordAt(0);
502 auto newType = newRecord->GetType();
503 ASSERT_EQ(newType, UDMF::OPENHARMONY_WANT);
504 auto recordValue = newRecord->GetValue();
505 auto wantValue = std::get_if<std::shared_ptr<OHOS::AAFwk::Want>>(&recordValue);
506 ASSERT_NE(wantValue, nullptr);
507 int32_t idValue2 = (*(wantValue))->GetIntParam("id", 0);
508 ASSERT_EQ(idValue2, 123);
509 }
510
511 /**
512 * @tc.name: Want2PasteRecord002
513 * @tc.desc: wantRecord is nullptr.
514 * @tc.type: FUNC
515 * @tc.require:
516 * @tc.author:
517 */
518 HWTEST_F(PasteboardUtilsTest, Want2PasteRecord002, TestSize.Level0)
519 {
520 std::shared_ptr<UDMF::UnifiedRecord> wantRecord;
521 auto pasteRecord = PasteboardUtils::Want2PasteRecord(wantRecord);
522 ASSERT_EQ(pasteRecord, nullptr);
523
524 auto ret = PasteboardUtils::PasteRecord2Want(pasteRecord);
525 ASSERT_EQ(ret, nullptr);
526 }
527
528 /**
529 * @tc.name: File2PasteRecord001
530 * @tc.desc: pasteData is local data.
531 * @tc.type: FUNC
532 * @tc.require:
533 * @tc.author:
534 */
535 HWTEST_F(PasteboardUtilsTest, File2PasteRecord001, TestSize.Level0)
536 {
537 auto data = InitFileData();
538 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
539 ASSERT_EQ(1, pasteData->GetRecordCount());
540 auto record = pasteData->GetRecordAt(0);
541 auto type = record->GetMimeType();
542 ASSERT_EQ(type, MIMETYPE_TEXT_URI);
543 auto udType = record->GetUDType();
544 ASSERT_EQ(udType, UDMF::UDType::FILE);
545 auto uri1 = record->GetUri()->ToString();
546 ASSERT_EQ(uri1, uri_);
547 auto details1 = record->GetDetails();
548 ASSERT_EQ(*details1, details_);
549
550 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
551 ASSERT_EQ(1, newData->GetRecords().size());
552 auto newRecord = newData->GetRecordAt(0);
553 auto newType = newRecord->GetType();
554 ASSERT_EQ(newType, UDMF::FILE);
555 auto newFileRecord = static_cast<UDMF::File *>(newRecord.get());
556 auto newDetails = newFileRecord->GetDetails();
557 ASSERT_EQ(newDetails, details_);
558 auto uri2 = newFileRecord->GetUri();
559 ASSERT_EQ(uri2, uri_);
560 }
561
562 /**
563 * @tc.name: File2PasteRecord002
564 * @tc.desc: fileRecord is nullptr.
565 * @tc.type: FUNC
566 * @tc.require:
567 * @tc.author:
568 */
569 HWTEST_F(PasteboardUtilsTest, File2PasteRecord002, TestSize.Level0)
570 {
571 std::shared_ptr<UDMF::File> fileRecord;
572 auto pasteRecord = PasteboardUtils::File2PasteRecord(fileRecord);
573 ASSERT_EQ(pasteRecord, nullptr);
574
575 auto ret = PasteboardUtils::PasteRecord2File(pasteRecord);
576 ASSERT_EQ(ret, nullptr);
577 }
578
579 /**
580 * @tc.name: Image2PasteRecord001
581 * @tc.desc: pasteData is local data.
582 * @tc.type: FUNC
583 * @tc.require:
584 * @tc.author:
585 */
586 HWTEST_F(PasteboardUtilsTest, Image2PasteRecord001, TestSize.Level0)
587 {
588 auto data = InitImageData();
589 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
590 ASSERT_EQ(1, pasteData->GetRecordCount());
591 auto record = pasteData->GetRecordAt(0);
592 auto type = record->GetMimeType();
593 ASSERT_EQ(type, MIMETYPE_TEXT_URI);
594 auto udType = record->GetUDType();
595 ASSERT_EQ(udType, UDMF::UDType::IMAGE);
596 auto uri1 = record->GetUri()->ToString();
597 ASSERT_EQ(uri1, uri_);
598 auto details1 = record->GetDetails();
599 ASSERT_EQ(*details1, details_);
600
601 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
602 ASSERT_EQ(1, newData->GetRecords().size());
603 auto newRecord = newData->GetRecordAt(0);
604 auto newType = newRecord->GetType();
605 ASSERT_EQ(newType, UDMF::IMAGE);
606 auto newImageRecord = static_cast<UDMF::Image *>(newRecord.get());
607 auto newDetails = newImageRecord->GetDetails();
608 ASSERT_EQ(newDetails, details_);
609 auto uri2 = newImageRecord->GetUri();
610 ASSERT_EQ(uri2, uri_);
611 }
612
613 /**
614 * @tc.name: Image2PasteRecord002
615 * @tc.desc: imageRecord is nullptr.
616 * @tc.type: FUNC
617 * @tc.require:
618 * @tc.author:
619 */
620 HWTEST_F(PasteboardUtilsTest, Image2PasteRecord002, TestSize.Level0)
621 {
622 std::shared_ptr<UDMF::Image> imageRecord;
623 auto pasteRecord = PasteboardUtils::Image2PasteRecord(imageRecord);
624 ASSERT_EQ(pasteRecord, nullptr);
625
626 auto ret = PasteboardUtils::PasteRecord2Image(pasteRecord);
627 ASSERT_EQ(ret, nullptr);
628 }
629
630 /**
631 * @tc.name: Audio2PasteRecord001
632 * @tc.desc: pasteData is local data.
633 * @tc.type: FUNC
634 * @tc.require:
635 * @tc.author:
636 */
637 HWTEST_F(PasteboardUtilsTest, Audio2PasteRecord001, TestSize.Level0)
638 {
639 auto data = InitAudioData();
640 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
641 ASSERT_EQ(1, pasteData->GetRecordCount());
642 auto record = pasteData->GetRecordAt(0);
643 auto type = record->GetMimeType();
644 ASSERT_EQ(type, MIMETYPE_TEXT_URI);
645 auto udType = record->GetUDType();
646 ASSERT_EQ(udType, UDMF::UDType::AUDIO);
647 auto uri1 = record->GetUri()->ToString();
648 ASSERT_EQ(uri1, uri_);
649 auto details1 = record->GetDetails();
650 ASSERT_EQ(*details1, details_);
651
652 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
653 ASSERT_EQ(1, newData->GetRecords().size());
654 auto newRecord = newData->GetRecordAt(0);
655 auto newType = newRecord->GetType();
656 ASSERT_EQ(newType, UDMF::AUDIO);
657 auto newAudioRecord = static_cast<UDMF::Audio *>(newRecord.get());
658 auto newDetails = newAudioRecord->GetDetails();
659 ASSERT_EQ(newDetails, details_);
660 auto uri2 = newAudioRecord->GetUri();
661 ASSERT_EQ(uri2, uri_);
662 }
663
664 /**
665 * @tc.name: Audio2PasteRecord002
666 * @tc.desc: audioRecord is nullptr.
667 * @tc.type: FUNC
668 * @tc.require:
669 * @tc.author:
670 */
671 HWTEST_F(PasteboardUtilsTest, Audio2PasteRecord002, TestSize.Level0)
672 {
673 std::shared_ptr<UDMF::Audio> audioRecord;
674 auto pasteRecord = PasteboardUtils::Audio2PasteRecord(audioRecord);
675 ASSERT_EQ(pasteRecord, nullptr);
676
677 auto ret = PasteboardUtils::PasteRecord2Audio(pasteRecord);
678 ASSERT_EQ(ret, nullptr);
679 }
680
681 /**
682 * @tc.name: Video2PasteRecord001
683 * @tc.desc: pasteData is local data.
684 * @tc.type: FUNC
685 * @tc.require:
686 * @tc.author:
687 */
688 HWTEST_F(PasteboardUtilsTest, Video2PasteRecord001, TestSize.Level0)
689 {
690 auto data = InitVideoData();
691 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
692 ASSERT_EQ(1, pasteData->GetRecordCount());
693 auto record = pasteData->GetRecordAt(0);
694 auto type = record->GetMimeType();
695 ASSERT_EQ(type, MIMETYPE_TEXT_URI);
696 auto udType = record->GetUDType();
697 ASSERT_EQ(udType, UDMF::UDType::VIDEO);
698 auto uri1 = record->GetUri()->ToString();
699 ASSERT_EQ(uri1, uri_);
700 auto details1 = record->GetDetails();
701 ASSERT_EQ(*details1, details_);
702
703 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
704 ASSERT_EQ(1, newData->GetRecords().size());
705 auto newRecord = newData->GetRecordAt(0);
706 auto newType = newRecord->GetType();
707 ASSERT_EQ(newType, UDMF::VIDEO);
708 auto newVideoRecord = static_cast<UDMF::Video *>(newRecord.get());
709 auto newDetails = newVideoRecord->GetDetails();
710 ASSERT_EQ(newDetails, details_);
711 auto uri2 = newVideoRecord->GetUri();
712 ASSERT_EQ(uri2, uri_);
713 }
714
715 /**
716 * @tc.name: Video2PasteRecord002
717 * @tc.desc: videoRecord is nullptr.
718 * @tc.type: FUNC
719 * @tc.require:
720 * @tc.author:
721 */
722 HWTEST_F(PasteboardUtilsTest, Video2PasteRecord002, TestSize.Level0)
723 {
724 std::shared_ptr<UDMF::Video> videoRecord;
725 auto pasteRecord = PasteboardUtils::Video2PasteRecord(videoRecord);
726 ASSERT_EQ(pasteRecord, nullptr);
727
728 auto ret = PasteboardUtils::PasteRecord2Video(pasteRecord);
729 ASSERT_EQ(ret, nullptr);
730 }
731
732 /**
733 * @tc.name: Folder2PasteRecord001
734 * @tc.desc: pasteData is local data.
735 * @tc.type: FUNC
736 * @tc.require:
737 * @tc.author:
738 */
739 HWTEST_F(PasteboardUtilsTest, Folder2PasteRecord001, TestSize.Level0)
740 {
741 auto data = InitFolderData();
742 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
743 ASSERT_EQ(1, pasteData->GetRecordCount());
744 auto record = pasteData->GetRecordAt(0);
745 auto type = record->GetMimeType();
746 ASSERT_EQ(type, MIMETYPE_TEXT_URI);
747 auto udType = record->GetUDType();
748 ASSERT_EQ(udType, UDMF::UDType::FOLDER);
749 auto uri1 = record->GetUri()->ToString();
750 ASSERT_EQ(uri1, uri_);
751 auto details1 = record->GetDetails();
752 ASSERT_EQ(*details1, details_);
753
754 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
755 ASSERT_EQ(1, newData->GetRecords().size());
756 auto newRecord = newData->GetRecordAt(0);
757 auto newType = newRecord->GetType();
758 ASSERT_EQ(newType, UDMF::FOLDER);
759 auto newFolderRecord = static_cast<UDMF::Folder *>(newRecord.get());
760 auto newDetails = newFolderRecord->GetDetails();
761 ASSERT_EQ(newDetails, details_);
762 auto uri2 = newFolderRecord->GetUri();
763 ASSERT_EQ(uri2, uri_);
764 }
765
766 /**
767 * @tc.name: Folder2PasteRecord002
768 * @tc.desc: folderRecord is nullptr.
769 * @tc.type: FUNC
770 * @tc.require:
771 * @tc.author:
772 */
773 HWTEST_F(PasteboardUtilsTest, Folder2PasteRecord002, TestSize.Level0)
774 {
775 std::shared_ptr<UDMF::Folder> folderRecord;
776 auto pasteRecord = PasteboardUtils::Folder2PasteRecord(folderRecord);
777 ASSERT_EQ(pasteRecord, nullptr);
778
779 auto ret = PasteboardUtils::PasteRecord2Folder(pasteRecord);
780 ASSERT_EQ(ret, nullptr);
781 }
782
783 /**
784 * @tc.name: SystemDefined2PasteRecord001
785 * @tc.desc: pasteData is local data.
786 * @tc.type: FUNC
787 * @tc.require:
788 * @tc.author:
789 */
790 HWTEST_F(PasteboardUtilsTest, SystemDefined2PasteRecord001, TestSize.Level0)
791 {
792 auto data = InitSystemRecordData();
793 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
794 ASSERT_EQ(1, pasteData->GetRecordCount());
795 auto record = pasteData->GetRecordAt(0);
796 auto type = record->GetMimeType();
797 ASSERT_EQ(type, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_RECORD));
798 auto udType = record->GetUDType();
799 ASSERT_EQ(udType, UDMF::SYSTEM_DEFINED_RECORD);
800 auto details1 = record->GetDetails();
801 ASSERT_EQ(*details1, details_);
802
803 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
804 ASSERT_EQ(1, newData->GetRecords().size());
805 auto newRecord = newData->GetRecordAt(0);
806 auto newType = newRecord->GetType();
807 ASSERT_EQ(newType, UDMF::SYSTEM_DEFINED_RECORD);
808 auto newSystemRecord = static_cast<UDMF::SystemDefinedRecord *>(newRecord.get());
809 ASSERT_EQ(newSystemRecord->GetDetails(), details_);
810 }
811
812 /**
813 * @tc.name: SystemDefined2PasteRecord002
814 * @tc.desc: systemRecord is nullptr.
815 * @tc.type: FUNC
816 * @tc.require:
817 * @tc.author:
818 */
819 HWTEST_F(PasteboardUtilsTest, SystemDefined2PasteRecord002, TestSize.Level0)
820 {
821 std::shared_ptr<UDMF::SystemDefinedRecord> systemRecord;
822 auto pasteRecord = PasteboardUtils::SystemDefined2PasteRecord(systemRecord);
823 ASSERT_EQ(pasteRecord, nullptr);
824
825 auto ret = PasteboardUtils::PasteRecord2SystemDefined(pasteRecord);
826 ASSERT_EQ(ret, nullptr);
827 }
828
829 /**
830 * @tc.name: AppItem2PasteRecord001
831 * @tc.desc: pasteData is local data.
832 * @tc.type: FUNC
833 * @tc.require:
834 * @tc.author:
835 */
836 HWTEST_F(PasteboardUtilsTest, AppItem2PasteRecord001, TestSize.Level0)
837 {
838 auto data = InitSystemAppItemData();
839 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
840 ASSERT_EQ(1, pasteData->GetRecordCount());
841 auto record = pasteData->GetRecordAt(0);
842 auto type = record->GetMimeType();
843 ASSERT_EQ(type, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_APP_ITEM));
844 auto udType = record->GetUDType();
845 ASSERT_EQ(udType, UDMF::SYSTEM_DEFINED_APP_ITEM);
846 auto details1 = record->GetDetails();
847 ASSERT_NE(details1, nullptr);
848 ASSERT_EQ(*details1, details_);
849 auto udmfValue = record->GetUDMFValue();
850 ASSERT_NE(udmfValue, nullptr);
851 auto newAppItem1 = std::make_shared<UDMF::SystemDefinedAppItem>(UDMF::SYSTEM_DEFINED_APP_ITEM, *udmfValue);
852 ASSERT_EQ(newAppItem1->GetAppId(), "appId");
853 ASSERT_EQ(newAppItem1->GetAppIconId(), "appIconId");
854 ASSERT_EQ(newAppItem1->GetAppName(), "appName");
855 ASSERT_EQ(newAppItem1->GetAppLabelId(), "appLabelId");
856 ASSERT_EQ(newAppItem1->GetBundleName(), "bundleName");
857 ASSERT_EQ(newAppItem1->GetAbilityName(), "abilityName");
858
859 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
860 ASSERT_EQ(1, newData->GetRecords().size());
861 auto newRecord = newData->GetRecordAt(0);
862 auto newType = newRecord->GetType();
863 ASSERT_EQ(newType, UDMF::SYSTEM_DEFINED_APP_ITEM);
864 auto newAppItem = static_cast<UDMF::SystemDefinedAppItem *>(newRecord.get());
865 ASSERT_EQ(newAppItem->GetAppId(), "appId");
866 ASSERT_EQ(newAppItem->GetAppIconId(), "appIconId");
867 ASSERT_EQ(newAppItem->GetAppName(), "appName");
868 ASSERT_EQ(newAppItem->GetAppLabelId(), "appLabelId");
869 ASSERT_EQ(newAppItem->GetBundleName(), "bundleName");
870 ASSERT_EQ(newAppItem->GetAbilityName(), "abilityName");
871 ASSERT_EQ(newAppItem->GetDetails(), details_);
872 }
873
874 /**
875 * @tc.name: AppItem2PasteRecord002
876 * @tc.desc: systemDefinedAppItem is nullptr.
877 * @tc.type: FUNC
878 * @tc.require:
879 * @tc.author:
880 */
881 HWTEST_F(PasteboardUtilsTest, AppItem2PasteRecord002, TestSize.Level0)
882 {
883 std::shared_ptr<UDMF::SystemDefinedAppItem> systemDefinedAppItem;
884 auto pasteRecord = PasteboardUtils::AppItem2PasteRecord(systemDefinedAppItem);
885 ASSERT_EQ(pasteRecord, nullptr);
886
887 auto ret = PasteboardUtils::PasteRecord2AppItem(pasteRecord);
888 ASSERT_EQ(ret, nullptr);
889 }
890
891 /**
892 * @tc.name: Form2PasteRecord001
893 * @tc.desc: pasteData is local data.
894 * @tc.type: FUNC
895 * @tc.require:
896 * @tc.author:
897 */
898 HWTEST_F(PasteboardUtilsTest, Form2PasteRecord001, TestSize.Level0)
899 {
900 auto data = InitSysteFormData();
901 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
902 ASSERT_EQ(1, pasteData->GetRecordCount());
903 auto record = pasteData->GetRecordAt(0);
904 auto type = record->GetMimeType();
905 ASSERT_EQ(type, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_FORM));
906 auto udType = record->GetUDType();
907 ASSERT_EQ(udType, UDMF::SYSTEM_DEFINED_FORM);
908 auto details1 = record->GetDetails();
909 auto content = *(record->GetSystemDefinedContent());
910 ASSERT_EQ(*details1, details_);
911 auto formId1 = std::get<std::int32_t>(content["formId"]);
912 auto formName1 = std::get<std::string>(content["formName"]);
913 auto module1 = std::get<std::string>(content["module"]);
914 auto bundleName1 = std::get<std::string>(content["bundleName"]);
915 auto abilityName1 = std::get<std::string>(content["abilityName"]);
916 ASSERT_EQ(1, formId1);
917 ASSERT_EQ("formName", formName1);
918 ASSERT_EQ("module", module1);
919 ASSERT_EQ("bundleName", bundleName1);
920 ASSERT_EQ("abilityName", abilityName1);
921
922 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
923 ASSERT_EQ(1, newData->GetRecords().size());
924 auto newRecord = newData->GetRecordAt(0);
925 auto newType = newRecord->GetType();
926 ASSERT_EQ(newType, UDMF::SYSTEM_DEFINED_FORM);
927 auto newForm = static_cast<UDMF::SystemDefinedForm *>(newRecord.get());
928 ASSERT_EQ(newForm->GetFormId(), formId1);
929 ASSERT_EQ(newForm->GetFormName(), formName1);
930 ASSERT_EQ(newForm->GetModule(), module1);
931 ASSERT_EQ(newForm->GetBundleName(), bundleName1);
932 ASSERT_EQ(newForm->GetAbilityName(), abilityName1);
933 ASSERT_EQ(newForm->GetDetails(), details_);
934 }
935
936 /**
937 * @tc.name: Form2PasteRecord002
938 * @tc.desc: form is nullptr.
939 * @tc.type: FUNC
940 * @tc.require:
941 * @tc.author:
942 */
943 HWTEST_F(PasteboardUtilsTest, Form2PasteRecord002, TestSize.Level0)
944 {
945 std::shared_ptr<UDMF::SystemDefinedForm> form;
946 auto pasteRecord = PasteboardUtils::Form2PasteRecord(form);
947 ASSERT_EQ(pasteRecord, nullptr);
948
949 auto ret = PasteboardUtils::PasteRecord2Form(pasteRecord);
950 ASSERT_EQ(ret, nullptr);
951 }
952
953 /**
954 * @tc.name: PixelMap2PasteRecord001
955 * @tc.desc: pasteData is local data.
956 * @tc.type: FUNC
957 * @tc.require:
958 * @tc.author:
959 */
960 HWTEST_F(PasteboardUtilsTest, PixelMap2PasteRecord001, TestSize.Level0)
961 {
962 auto data = InitSystemPixelMapData();
963 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
964 ASSERT_EQ(1, pasteData->GetRecordCount());
965 auto record = pasteData->GetRecordAt(0);
966 auto type = record->GetMimeType();
967 ASSERT_EQ(type, MIMETYPE_PIXELMAP);
968 auto udType = record->GetUDType();
969 ASSERT_EQ(udType, int32_t(UDMF::UDType::SYSTEM_DEFINED_PIXEL_MAP));
970 auto newPixelMap = record->GetPixelMap();
971 ASSERT_TRUE(newPixelMap != nullptr);
972 ImageInfo imageInfo = {};
973 newPixelMap->GetImageInfo(imageInfo);
974 ASSERT_TRUE(imageInfo.size.height == 7);
975 ASSERT_TRUE(imageInfo.size.width == 5);
976 ASSERT_TRUE(imageInfo.pixelFormat == PixelFormat::ARGB_8888);
977
978 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
979 ASSERT_EQ(1, newData->GetRecords().size());
980 auto newRecord = newData->GetRecordAt(0);
981 auto newType = newRecord->GetType();
982 ASSERT_EQ(newType, UDMF::SYSTEM_DEFINED_PIXEL_MAP);
983 auto recordValue = newRecord->GetValue();
984 auto newPixelMap1 = std::get_if<std::shared_ptr<OHOS::Media::PixelMap>>(&recordValue);
985 ASSERT_NE(newPixelMap1, nullptr);
986 ImageInfo imageInfo1 = {};
987 (*newPixelMap1)->GetImageInfo(imageInfo1);
988 ASSERT_TRUE(imageInfo1.size.height == imageInfo.size.height);
989 ASSERT_TRUE(imageInfo1.size.width == imageInfo.size.width);
990 ASSERT_TRUE(imageInfo1.pixelFormat == imageInfo.pixelFormat);
991 }
992
993 /**
994 * @tc.name: PixelMap2PasteRecord002
995 * @tc.desc: pixelMapRecord is nullptr.
996 * @tc.type: FUNC
997 * @tc.require:
998 * @tc.author:
999 */
1000 HWTEST_F(PasteboardUtilsTest, PixelMap2PasteRecord002, TestSize.Level0)
1001 {
1002 std::shared_ptr<UDMF::UnifiedRecord> pixelMapRecord;
1003 auto pasteRecord = PasteboardUtils::PixelMap2PasteRecord(pixelMapRecord);
1004 ASSERT_EQ(pasteRecord, nullptr);
1005
1006 auto ret = PasteboardUtils::PasteRecord2PixelMap(pasteRecord);
1007 ASSERT_EQ(ret, nullptr);
1008 }
1009
1010 /**
1011 * @tc.name: AppDefined2PasteRecord001
1012 * @tc.desc: pasteData is local data.
1013 * @tc.type: FUNC
1014 * @tc.require:
1015 * @tc.author:
1016 */
1017 HWTEST_F(PasteboardUtilsTest, AppDefined2PasteRecord001, TestSize.Level0)
1018 {
1019 auto data = InitAppDefinedData();
1020 auto pasteData = PasteboardUtils::GetInstance().Convert(data);
1021 ASSERT_EQ(1, pasteData->GetRecordCount());
1022 auto record = pasteData->GetRecordAt(0);
1023 auto type = record->GetMimeType();
1024 ASSERT_EQ(type, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::APPLICATION_DEFINED_RECORD));
1025 auto udType = record->GetUDType();
1026 ASSERT_EQ(udType, UDMF::APPLICATION_DEFINED_RECORD);
1027 auto items = record->GetCustomData()->GetItemData();
1028 std::map<std::string, std::vector<uint8_t>> customData {
1029 {type, rawData_}
1030 };
1031 ASSERT_EQ(items, customData);
1032
1033 auto newData = PasteboardUtils::GetInstance().Convert(*pasteData);
1034 ASSERT_EQ(1, newData->GetRecords().size());
1035 auto newRecord = newData->GetRecordAt(0);
1036 auto newType = newRecord->GetType();
1037 ASSERT_EQ(newType, UDMF::APPLICATION_DEFINED_RECORD);
1038 auto newSystemRecord = static_cast<UDMF::ApplicationDefinedRecord *>(newRecord.get());
1039 ASSERT_EQ(newSystemRecord->GetRawData(), rawData_);
1040 }
1041
1042 /**
1043 * @tc.name: AppDefined2PasteRecord002
1044 * @tc.desc: appRecord is nullptr.
1045 * @tc.type: FUNC
1046 * @tc.require:
1047 * @tc.author:
1048 */
1049 HWTEST_F(PasteboardUtilsTest, AppDefined2PasteRecord002, TestSize.Level0)
1050 {
1051 std::shared_ptr<UDMF::ApplicationDefinedRecord> appRecord;
1052 auto pasteRecord = PasteboardUtils::AppDefined2PasteRecord(appRecord);
1053 ASSERT_EQ(pasteRecord, nullptr);
1054
1055 auto ret = PasteboardUtils::Custom2AppDefined(pasteRecord);
1056 ASSERT_EQ(ret.size(), 0);
1057 }
1058
1059 /**
1060 * @tc.name: ConvertTest001
1061 * @tc.desc: Traverse UDType.
1062 * @tc.type: FUNC
1063 * @tc.require:
1064 * @tc.author:
1065 */
1066 HWTEST_F(PasteboardUtilsTest, ConvertTest001, TestSize.Level0)
1067 {
1068 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UDType::PLAIN_TEXT), MIMETYPE_TEXT_PLAIN);
1069 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UDType::HTML), MIMETYPE_TEXT_HTML);
1070 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UDType::FILE_URI), MIMETYPE_TEXT_URI);
1071 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UDType::SYSTEM_DEFINED_PIXEL_MAP), MIMETYPE_PIXELMAP);
1072 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UDType::OPENHARMONY_WANT), MIMETYPE_TEXT_WANT);
1073 }
1074
1075 /**
1076 * @tc.name: ConvertTest002
1077 * @tc.desc: Traverse MIMEType.
1078 * @tc.type: FUNC
1079 * @tc.require:
1080 * @tc.author:
1081 */
1082 HWTEST_F(PasteboardUtilsTest, ConvertTest002, TestSize.Level0)
1083 {
1084 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UD_BUTT, MIMETYPE_TEXT_URI), UDMF::FILE);
1085 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UD_BUTT, MIMETYPE_TEXT_PLAIN), UDMF::PLAIN_TEXT);
1086 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UD_BUTT, MIMETYPE_TEXT_HTML), UDMF::HTML);
1087 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UD_BUTT, MIMETYPE_TEXT_WANT), UDMF::OPENHARMONY_WANT);
1088 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UD_BUTT, MIMETYPE_PIXELMAP), UDMF::SYSTEM_DEFINED_PIXEL_MAP);
1089 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UD_BUTT, text_), UDMF::UD_BUTT);
1090 std::string mimeType = "general.jpeg-2000";
1091 ASSERT_EQ(PasteboardUtils::Convert(UDMF::UD_BUTT, mimeType), UDMF::JPEG2000);
1092 }
1093
1094 /**
1095 * @tc.name: ConvertShareOptionTest001
1096 * @tc.desc: Test Convert function when properties.shareOptions is UDMF::IN_APP
1097 * @tc.type: FUNC
1098 * @tc.require:
1099 */
1100 HWTEST_F(PasteboardUtilsTest, ConvertShareOptionTest001, TestSize.Level0)
1101 {
1102 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest001 start");
1103 UDMF::UnifiedDataProperties properties;
1104 PasteDataProperty result;
1105
1106 properties.shareOptions = UDMF::IN_APP;
1107 result.shareOption = LocalDevice;
1108 result = PasteboardUtils::Convert(properties);
1109 EXPECT_EQ(result.shareOption, InApp);
1110 result.shareOption = CrossDevice;
1111 result = PasteboardUtils::Convert(properties);
1112 EXPECT_EQ(result.shareOption, InApp);
1113 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest001 end");
1114 }
1115
1116 /**
1117 * @tc.name: ConvertShareOptionTest002
1118 * @tc.desc: Test Convert function when properties.shareOptions is UDMF::CROSS_APP
1119 * @tc.type: FUNC
1120 * @tc.require:
1121 */
1122 HWTEST_F(PasteboardUtilsTest, ConvertShareOptionTest002, TestSize.Level0)
1123 {
1124 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest002 start");
1125 UDMF::UnifiedDataProperties properties;
1126 PasteDataProperty result;
1127
1128 properties.shareOptions = UDMF::CROSS_APP;
1129 result.shareOption = InApp;
1130 result = PasteboardUtils::Convert(properties);
1131 EXPECT_EQ(result.shareOption, LocalDevice);
1132 result.shareOption = CrossDevice;
1133 result = PasteboardUtils::Convert(properties);
1134 EXPECT_EQ(result.shareOption, LocalDevice);
1135
1136 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest002 end");
1137 }
1138
1139 /**
1140 * @tc.name: ConvertShareOptionTest003
1141 * @tc.desc: Test Convert function when properties.shareOptions is UDMF::CROSS_DEVICE
1142 * @tc.type: FUNC
1143 * @tc.require:
1144 */
1145 HWTEST_F(PasteboardUtilsTest, ConvertShareOptionTest003, TestSize.Level0)
1146 {
1147 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest003 start");
1148 UDMF::UnifiedDataProperties properties;
1149 PasteDataProperty result;
1150
1151 properties.shareOptions = UDMF::CROSS_DEVICE;
1152 result.shareOption = InApp;
1153 result = PasteboardUtils::Convert(properties);
1154 EXPECT_EQ(result.shareOption, CrossDevice);
1155 result.shareOption = CrossDevice;
1156 result = PasteboardUtils::Convert(properties);
1157 EXPECT_EQ(result.shareOption, CrossDevice);
1158
1159 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest003 end");
1160 }
1161
1162 /**
1163 * @tc.name: ConvertShareOptionTest004
1164 * @tc.desc: Test Convert function when properties.shareOptions is UDMF::SHARE_OPTIONS_BUTT
1165 * @tc.type: FUNC
1166 * @tc.require:
1167 */
1168 HWTEST_F(PasteboardUtilsTest, ConvertShareOptionTest004, TestSize.Level0)
1169 {
1170 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest004 start");
1171 UDMF::UnifiedDataProperties properties;
1172 PasteDataProperty result;
1173
1174 properties.shareOptions = UDMF::SHARE_OPTIONS_BUTT;
1175 result.shareOption = InApp;
1176 result = PasteboardUtils::Convert(properties);
1177 EXPECT_EQ(result.shareOption, CrossDevice);
1178 result.shareOption = CrossDevice;
1179 result = PasteboardUtils::Convert(properties);
1180 EXPECT_EQ(result.shareOption, CrossDevice);
1181
1182 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest004 end");
1183 }
1184
1185 /**
1186 * @tc.name: ConvertShareOptionTest005
1187 * @tc.desc: Test Convert function when properties.shareOption is InApp
1188 * @tc.type: FUNC
1189 * @tc.require:
1190 */
1191 HWTEST_F(PasteboardUtilsTest, ConvertShareOptionTest005, TestSize.Level0)
1192 {
1193 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest005 start");
1194 PasteDataProperty properties;
1195 std::shared_ptr<UDMF::UnifiedDataProperties> result = std::make_shared<UDMF::UnifiedDataProperties>();
1196
1197 properties.shareOption = InApp;
1198 result->shareOptions = UDMF::CROSS_APP;
1199 result = PasteboardUtils::Convert(properties);
1200 EXPECT_EQ(result->shareOptions, UDMF::IN_APP);
1201 result->shareOptions = UDMF::CROSS_DEVICE;
1202 result = PasteboardUtils::Convert(properties);
1203 EXPECT_EQ(result->shareOptions, UDMF::IN_APP);
1204
1205 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest005 end");
1206 }
1207
1208 /**
1209 * @tc.name: ConvertShareOptionTest006
1210 * @tc.desc: Test Convert function when properties.shareOption is LocalDevice
1211 * @tc.type: FUNC
1212 * @tc.require:
1213 */
1214 HWTEST_F(PasteboardUtilsTest, ConvertShareOptionTest006, TestSize.Level0)
1215 {
1216 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest006 start");
1217 PasteDataProperty properties;
1218 std::shared_ptr<UDMF::UnifiedDataProperties> result = std::make_shared<UDMF::UnifiedDataProperties>();
1219
1220 properties.shareOption = LocalDevice;
1221 result->shareOptions = UDMF::IN_APP;
1222 result = PasteboardUtils::Convert(properties);
1223 EXPECT_EQ(result->shareOptions, UDMF::CROSS_APP);
1224 result->shareOptions = UDMF::CROSS_DEVICE;
1225 result = PasteboardUtils::Convert(properties);
1226 EXPECT_EQ(result->shareOptions, UDMF::CROSS_APP);
1227
1228 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest006 end");
1229 }
1230
1231 /**
1232 * @tc.name: ConvertShareOptionTest007
1233 * @tc.desc: Test Convert function when properties.shareOption is CrossDevice
1234 * @tc.type: FUNC
1235 * @tc.require:
1236 */
1237 HWTEST_F(PasteboardUtilsTest, ConvertShareOptionTest007, TestSize.Level0)
1238 {
1239 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest007 start");
1240 PasteDataProperty properties;
1241 std::shared_ptr<UDMF::UnifiedDataProperties> result = std::make_shared<UDMF::UnifiedDataProperties>();
1242
1243 properties.shareOption = CrossDevice;
1244 result->shareOptions = UDMF::IN_APP;
1245 result = PasteboardUtils::Convert(properties);
1246 EXPECT_EQ(result->shareOptions, UDMF::CROSS_DEVICE);
1247 result->shareOptions = UDMF::CROSS_APP;
1248 result = PasteboardUtils::Convert(properties);
1249 EXPECT_EQ(result->shareOptions, UDMF::CROSS_DEVICE);
1250
1251 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "ConvertShareOptionTest007 end");
1252 }
1253
1254 /**
1255 * @tc.name: DeduplicateVectorTest
1256 * @tc.desc: Remove duplicate value from string vector
1257 * @tc.type: FUNC
1258 * @tc.require:
1259 */
1260 HWTEST_F(PasteboardUtilsTest, DeduplicateVectorTest, TestSize.Level0)
1261 {
1262 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "DeduplicateVectorTest start");
1263 const std::vector<std::string> vec1(3, "test");
1264 const std::vector<std::string> vec2(1, "test");
1265 std::vector<std::string> result = PasteboardUtils::GetInstance().DeduplicateVector(vec1);
1266 EXPECT_EQ(std::equal(result.begin(), result.end(), vec2.begin()), true);
1267 const std::vector<std::string> vec3 = {"a", "b", "c", "a", "b", "c"};
1268 std::vector<std::string> vec4 = {"a", "b", "c"};
1269 result = PasteboardUtils::GetInstance().DeduplicateVector(vec3);
1270 EXPECT_EQ(result.size(), vec4.size());
1271 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "DeduplicateVectorTest end");
1272 }
1273
1274 } // namespace OHOS::MiscServices