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 "entry_getter.h"
19 #include "paste_data_record.h"
20 #include "unified_meta.h"
21
22 namespace OHOS::MiscServices {
23 using namespace testing::ext;
24 using namespace testing;
25 using namespace OHOS::Media;
26 class PasteDataRecordTest : public testing::Test {
27 public:
28 static void SetUpTestCase(void);
29 static void TearDownTestCase(void);
30 void SetUp();
31 void TearDown();
32
33 protected:
34 Details details_;
35 std::vector<uint8_t> rawData_;
36 std::string text_ = "test";
37 std::string extraText_ = "extr";
38 std::string uri_ = "file://123.txt";
39 std::string html_ = "<div class='disable'>helloWorld</div>";
40 std::string link_ = "http://abc.com";
41 int32_t width_ = 5;
42 int32_t height_ = 7;
43
44 void CheckEntries(const std::vector<std::shared_ptr<PasteDataEntry>> &entries);
45 void CheckPlainUds(const std::shared_ptr<PasteDataEntry> entry);
46 void CheckFileUriUds(const std::shared_ptr<PasteDataEntry> entry);
47 void CheckPixelMapUds(const std::shared_ptr<PasteDataEntry> entry);
48 void CheckHtmlUds(const std::shared_ptr<PasteDataEntry> entry);
49 void CheckLinkUds(const std::shared_ptr<PasteDataEntry> entry);
50
51 void AddPlainUdsEntry(PasteDataRecord &record);
52 void AddFileUriUdsEntry(PasteDataRecord &record);
53 void AddHtmlUdsEntry(PasteDataRecord &record);
54 void AddPixelMapUdsEntry(PasteDataRecord &record);
55 void AddLinkUdsEntry(PasteDataRecord &record);
56 };
57
SetUpTestCase(void)58 void PasteDataRecordTest::SetUpTestCase(void) { }
59
TearDownTestCase(void)60 void PasteDataRecordTest::TearDownTestCase(void) { }
61
SetUp(void)62 void PasteDataRecordTest::SetUp(void)
63 {
64 rawData_ = { 1, 2, 3, 4, 5, 6, 7, 8 };
65 details_.insert({ "keyString", "string_test" });
66 details_.insert({ "keyInt32", 1 });
67 details_.insert({ "keyBool", true });
68 details_.insert({ "KeyU8Array", rawData_ });
69 details_.insert({ "KeyDouble", 1.234 });
70 }
71
TearDown(void)72 void PasteDataRecordTest::TearDown(void) { }
73
AddPlainUdsEntry(PasteDataRecord & record)74 void PasteDataRecordTest::AddPlainUdsEntry(PasteDataRecord &record)
75 {
76 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
77 auto object = std::make_shared<Object>();
78 object->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
79 object->value_[UDMF::CONTENT] = text_;
80 record.AddEntry(utdId, std::make_shared<PasteDataEntry>(utdId, object));
81 }
82
AddFileUriUdsEntry(PasteDataRecord & record)83 void PasteDataRecordTest::AddFileUriUdsEntry(PasteDataRecord &record)
84 {
85 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI);
86 auto object = std::make_shared<Object>();
87 object->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
88 object->value_[UDMF::FILE_URI_PARAM] = uri_;
89 object->value_[UDMF::FILE_TYPE] = "";
90 record.AddEntry(utdId, std::make_shared<PasteDataEntry>(utdId, object));
91 }
92
AddHtmlUdsEntry(PasteDataRecord & record)93 void PasteDataRecordTest::AddHtmlUdsEntry(PasteDataRecord &record)
94 {
95 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML);
96 auto object = std::make_shared<Object>();
97 object->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
98 object->value_[UDMF::HTML_CONTENT] = html_;
99 record.AddEntry(utdId, std::make_shared<PasteDataEntry>(utdId, object));
100 }
101
AddLinkUdsEntry(PasteDataRecord & record)102 void PasteDataRecordTest::AddLinkUdsEntry(PasteDataRecord &record)
103 {
104 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK);
105 auto object = std::make_shared<Object>();
106 object->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
107 object->value_[UDMF::URL] = link_;
108 record.AddEntry(utdId, std::make_shared<PasteDataEntry>(utdId, object));
109 }
110
AddPixelMapUdsEntry(PasteDataRecord & record)111 void PasteDataRecordTest::AddPixelMapUdsEntry(PasteDataRecord &record)
112 {
113 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP);
114 auto object = std::make_shared<Object>();
115 object->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
116 uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
117 InitializationOptions opts = {
118 {width_, height_},
119 PixelFormat::ARGB_8888, PixelFormat::ARGB_8888
120 };
121 std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
122 std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
123 object->value_[UDMF::PIXEL_MAP] = pixelMapIn;
124 record.AddEntry(utdId, std::make_shared<PasteDataEntry>(utdId, object));
125 }
126
CheckEntries(const std::vector<std::shared_ptr<PasteDataEntry>> & entries)127 void PasteDataRecordTest::CheckEntries(const std::vector<std::shared_ptr<PasteDataEntry>> &entries)
128 {
129 for (auto const &entry : entries) {
130 if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT)) {
131 CheckPlainUds(entry);
132 }
133 if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI)) {
134 CheckFileUriUds(entry);
135 }
136 if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP)) {
137 CheckPixelMapUds(entry);
138 }
139 if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK)) {
140 CheckLinkUds(entry);
141 }
142 if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML)) {
143 CheckHtmlUds(entry);
144 }
145 }
146 }
147
CheckPlainUds(const std::shared_ptr<PasteDataEntry> entry)148 void PasteDataRecordTest::CheckPlainUds(const std::shared_ptr<PasteDataEntry> entry)
149 {
150 ASSERT_EQ(MIMETYPE_TEXT_PLAIN, entry->GetMimeType());
151 auto decodeValue = entry->GetValue();
152 auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
153 ASSERT_NE(object, nullptr);
154 auto objectValue = (*object)->value_;
155 auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
156 ASSERT_NE(typeValue, nullptr);
157 ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT));
158 auto value = std::get_if<std::string>(&objectValue[UDMF::CONTENT]);
159 ASSERT_NE(value, nullptr);
160 ASSERT_EQ(*value, text_);
161 }
162
CheckFileUriUds(const std::shared_ptr<PasteDataEntry> entry)163 void PasteDataRecordTest::CheckFileUriUds(const std::shared_ptr<PasteDataEntry> entry)
164 {
165 ASSERT_EQ(MIMETYPE_TEXT_URI, entry->GetMimeType());
166 auto decodeValue = entry->GetValue();
167 auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
168 ASSERT_NE(object, nullptr);
169 auto objectValue = (*object)->value_;
170 auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
171 ASSERT_NE(typeValue, nullptr);
172 ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI));
173 auto value = std::get_if<std::string>(&objectValue[UDMF::FILE_URI_PARAM]);
174 ASSERT_NE(value, nullptr);
175 ASSERT_EQ(*value, uri_);
176 }
177
CheckHtmlUds(const std::shared_ptr<PasteDataEntry> entry)178 void PasteDataRecordTest::CheckHtmlUds(const std::shared_ptr<PasteDataEntry> entry)
179 {
180 ASSERT_EQ(MIMETYPE_TEXT_HTML, entry->GetMimeType());
181 auto decodeValue = entry->GetValue();
182 auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
183 ASSERT_NE(object, nullptr);
184 auto objectValue = (*object)->value_;
185 auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
186 ASSERT_NE(typeValue, nullptr);
187 ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML));
188 auto value = std::get_if<std::string>(&objectValue[UDMF::HTML_CONTENT]);
189 ASSERT_NE(value, nullptr);
190 ASSERT_EQ(*value, html_);
191 }
192
CheckPixelMapUds(const std::shared_ptr<PasteDataEntry> entry)193 void PasteDataRecordTest::CheckPixelMapUds(const std::shared_ptr<PasteDataEntry> entry)
194 {
195 ASSERT_EQ(MIMETYPE_PIXELMAP, entry->GetMimeType());
196 auto decodeValue = entry->GetValue();
197 auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
198 ASSERT_NE(object, nullptr);
199 auto objectValue = (*object)->value_;
200 auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
201 ASSERT_NE(typeValue, nullptr);
202 ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP));
203 auto value = std::get_if<std::shared_ptr<PixelMap>>(&objectValue[UDMF::PIXEL_MAP]);
204 ASSERT_NE(value, nullptr);
205 ImageInfo imageInfo = {};
206 (*value)->GetImageInfo(imageInfo);
207 ASSERT_TRUE(imageInfo.size.height == height_);
208 ASSERT_TRUE(imageInfo.size.width == width_);
209 ASSERT_TRUE(imageInfo.pixelFormat == PixelFormat::ARGB_8888);
210 }
211
CheckLinkUds(const std::shared_ptr<PasteDataEntry> entry)212 void PasteDataRecordTest::CheckLinkUds(const std::shared_ptr<PasteDataEntry> entry)
213 {
214 ASSERT_EQ(MIMETYPE_TEXT_PLAIN, entry->GetMimeType());
215 auto decodeValue = entry->GetValue();
216 auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
217 ASSERT_NE(object, nullptr);
218 auto objectValue = (*object)->value_;
219 auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
220 ASSERT_NE(typeValue, nullptr);
221 ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK));
222 auto value = std::get_if<std::string>(&objectValue[UDMF::URL]);
223 ASSERT_NE(value, nullptr);
224 ASSERT_EQ(*value, link_);
225 }
226
227 /**
228 * @tc.name: GetValidTypesTest001
229 * @tc.desc: GetValidTypesTest001;
230 * @tc.type: FUNC
231 * @tc.require:entries
232 * @tc.author: tarowang
233 */
234 HWTEST_F(PasteDataRecordTest, GetValidTypesTest001, TestSize.Level0)
235 {
236 std::shared_ptr<PasteDataRecord> record = std::make_shared<PasteDataRecord>();
237 AddPlainUdsEntry(*record);
238 AddHtmlUdsEntry(*record);
239
240 std::vector<std::string> inputTypes;
241 inputTypes.emplace_back(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI));
242 inputTypes.emplace_back(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML));
243
244 auto validTypes = record->GetValidTypes(inputTypes);
245 ASSERT_EQ(validTypes.size(), 1);
246 ASSERT_EQ(validTypes[0], UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML));
247 }
248
249 /**
250 * @tc.name: AddEntryTest001
251 * @tc.desc: Add entry test
252 * @tc.type: FUNC
253 * @tc.require:entries
254 * @tc.author: tarowang
255 */
256 HWTEST_F(PasteDataRecordTest, AddEntryTest001, TestSize.Level0)
257 {
258 std::shared_ptr<PasteDataRecord> record = std::make_shared<PasteDataRecord>();
259 AddPlainUdsEntry(*record);
260 AddHtmlUdsEntry(*record);
261 std::set<std::string> mimeTypes = record->GetMimeTypes();
262 EXPECT_NE(mimeTypes.find(MIMETYPE_TEXT_PLAIN), mimeTypes.end());
263 EXPECT_NE(mimeTypes.find(MIMETYPE_TEXT_HTML), mimeTypes.end());
264 }
265
266 /**
267 * @tc.name: GetEntries001
268 * @tc.desc: convert to plainText;
269 * @tc.type: FUNC
270 * @tc.require:entries
271 * @tc.author: tarowang
272 */
273 HWTEST_F(PasteDataRecordTest, GetEntries001, TestSize.Level0)
274 {
275 std::vector<std::string> inputTypes;
276 inputTypes.emplace_back(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI));
277 inputTypes.emplace_back(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML));
278 inputTypes.emplace_back(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI));
279 inputTypes.emplace_back(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK));
280 inputTypes.emplace_back(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP));
281
282 std::shared_ptr<PasteDataRecord> record = std::make_shared<PasteDataRecord>();
283 AddPlainUdsEntry(*record);
284 auto types = record->GetValidTypes(inputTypes);
285 ASSERT_EQ(types.size(), 0);
286
287 AddHtmlUdsEntry(*record);
288 types = record->GetValidTypes(inputTypes);
289 auto it = std::find(types.begin(), types.end(), UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML));
290 ASSERT_NE(it, types.end());
291
292 AddFileUriUdsEntry(*record);
293 types = record->GetValidTypes(inputTypes);
294 it = std::find(types.begin(), types.end(), UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI));
295 ASSERT_NE(it, types.end());
296
297 AddLinkUdsEntry(*record);
298 types = record->GetValidTypes(inputTypes);
299 it = std::find(types.begin(), types.end(), UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK));
300 ASSERT_NE(it, types.end());
301
302 AddPixelMapUdsEntry(*record);
303 types = record->GetValidTypes(inputTypes);
304 it = std::find(types.begin(), types.end(), UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP));
305 ASSERT_NE(it, types.end());
306
307 auto entries = record->GetEntries();
308 CheckEntries(entries);
309 }
310
311 /**
312 * @tc.name: BuilderTest001
313 * @tc.desc: PasteDataRecord::Builder
314 * @tc.type: FUNC
315 */
316 HWTEST_F(PasteDataRecordTest, BuilderTest001, TestSize.Level0)
317 {
318 PasteDataRecord::Builder builder("");
319 builder.SetHtmlText(nullptr);
320 builder.SetWant(nullptr);
321 builder.SetPlainText(nullptr);
322 builder.SetUri(nullptr);
323 builder.SetPixelMap(nullptr);
324 builder.SetCustomData(nullptr);
325 builder.SetMimeType("");
326
327 auto record = builder.Build();
328 EXPECT_NE(record, nullptr);
329 }
330
331 /**
332 * @tc.name: SetUriTest001
333 * @tc.desc: SetUri & GetUriV0
334 * @tc.type: FUNC
335 */
336 HWTEST_F(PasteDataRecordTest, SetUriTest001, TestSize.Level0)
337 {
338 PasteDataRecord record;
339 record.SetUri(nullptr);
340
341 auto uri = record.GetUriV0();
342 EXPECT_EQ(uri, nullptr);
343 }
344
345 /**
346 * @tc.name: NewMultiTypeRecordTest001
347 * @tc.desc: NewMultiTypeRecord
348 * @tc.type: FUNC
349 */
350 HWTEST_F(PasteDataRecordTest, NewMultiTypeRecordTest001, TestSize.Level0)
351 {
352 PasteDataRecord record;
353
354 auto ret = record.NewMultiTypeRecord(nullptr, "");
355 EXPECT_NE(ret, nullptr);
356
357 ret = record.NewMultiTypeRecord(nullptr, "0");
358 EXPECT_NE(ret, nullptr);
359
360 auto values = std::make_shared<std::map<std::string, std::shared_ptr<EntryValue>>>();
361 ASSERT_NE(values, nullptr);
362
363 ret = record.NewMultiTypeRecord(nullptr, "0");
364 EXPECT_NE(ret, nullptr);
365
366 (*values)["0"] = nullptr;
367 ret = record.NewMultiTypeRecord(nullptr, "0");
368 EXPECT_NE(ret, nullptr);
369
370 (*values)["0"] = std::make_shared<EntryValue>();
371 (*values)["1"] = std::make_shared<EntryValue>();
372 ret = record.NewMultiTypeRecord(nullptr, "0");
373 EXPECT_NE(ret, nullptr);
374
375 ret = record.NewMultiTypeRecord(nullptr, "");
376 EXPECT_NE(ret, nullptr);
377
378 ret = record.NewMultiTypeRecord(nullptr, "2");
379 EXPECT_NE(ret, nullptr);
380 }
381
382 class EntryGetterImplement : public UDMF::EntryGetter {
383 public:
GetValueByType(const std::string & utdId)384 UDMF::ValueType GetValueByType(const std::string &utdId) override
385 {
386 return nullptr;
387 }
388 };
389
390 /**
391 * @tc.name: GetEntryGetterTest001
392 * @tc.desc: SetEntryGetter & GetEntryGetter
393 * @tc.type: FUNC
394 */
395 HWTEST_F(PasteDataRecordTest, GetEntryGetterTest001, TestSize.Level0)
396 {
397 PasteDataRecord record;
398 std::shared_ptr<UDMF::EntryGetter> entryGetter = nullptr;
399 record.SetEntryGetter(entryGetter);
400 auto ret = record.GetEntryGetter();
401 EXPECT_EQ(ret, nullptr);
402
403 entryGetter = std::make_shared<EntryGetterImplement>();
404 record.SetEntryGetter(entryGetter);
405 ret = record.GetEntryGetter();
406 EXPECT_NE(ret, nullptr);
407 }
408
409 /**
410 * @tc.name: NewMultiTypeDelayRecordTest001
411 * @tc.desc: NewMultiTypeDelayRecord
412 * @tc.type: FUNC
413 */
414 HWTEST_F(PasteDataRecordTest, NewMultiTypeDelayRecordTest001, TestSize.Level0)
415 {
416 PasteDataRecord record;
417 std::vector<std::string> mimeTypes = { "0", "1", "2" };
418 auto ret = record.NewMultiTypeDelayRecord(mimeTypes, nullptr);
419 EXPECT_NE(ret, nullptr);
420
421 auto entryGetter = std::make_shared<EntryGetterImplement>();
422 ret = record.NewMultiTypeDelayRecord(mimeTypes, entryGetter);
423 EXPECT_NE(ret, nullptr);
424 }
425
426 /**
427 * @tc.name: ClearPixelMapTest001
428 * @tc.desc: ClearPixelMap & GetPixelMapV0
429 * @tc.type: FUNC
430 */
431 HWTEST_F(PasteDataRecordTest, ClearPixelMapTest001, TestSize.Level0)
432 {
433 auto pixelMap = std::make_shared<OHOS::Media::PixelMap>();
434 auto record = PasteDataRecord::NewPixelMapRecord(pixelMap);
435 ASSERT_NE(record, nullptr);
436
437 pixelMap = record->GetPixelMapV0();
438 EXPECT_NE(pixelMap, nullptr);
439
440 record->ClearPixelMap();
441 pixelMap = record->GetPixelMapV0();
442 EXPECT_EQ(pixelMap, nullptr);
443 }
444
445 /**
446 * @tc.name: GetHtmlTextV0Test001
447 * @tc.desc: GetHtmlTextV0
448 * @tc.type: FUNC
449 */
450 HWTEST_F(PasteDataRecordTest, GetHtmlTextV0Test001, TestSize.Level0)
451 {
452 std::string html = html_;
453 std::shared_ptr<PasteDataRecord> record = PasteDataRecord::NewHtmlRecord(html);
454 ASSERT_NE(record, nullptr);
455
456 auto htmlText = record->GetHtmlTextV0();
457 EXPECT_NE(htmlText, nullptr);
458 }
459
460 /**
461 * @tc.name: GetHtmlTextV0Test002
462 * @tc.desc: GetHtmlTextV0
463 * @tc.type: FUNC
464 */
465 HWTEST_F(PasteDataRecordTest, GetHtmlTextV0Test002, TestSize.Level0)
466 {
467 std::string text = text_;
468 std::shared_ptr<PasteDataRecord> record = PasteDataRecord::NewPlainTextRecord(text);
469 ASSERT_NE(record, nullptr);
470
471 auto htmlText = record->GetHtmlTextV0();
472 EXPECT_EQ(htmlText, nullptr);
473 }
474
475 /**
476 * @tc.name: GetHtmlTextV0Test003
477 * @tc.desc: GetHtmlTextV0
478 * @tc.type: FUNC
479 */
480 HWTEST_F(PasteDataRecordTest, GetHtmlTextV0Test003, TestSize.Level0)
481 {
482 std::string html = nullptr;
483 std::shared_ptr<PasteDataRecord> record = PasteDataRecord::NewHtmlRecord(html);
484 ASSERT_NE(record, nullptr);
485
486 auto htmlText = record->GetHtmlTextV0();
487 EXPECT_EQ(htmlText, nullptr);
488 }
489
490 /**
491 * @tc.name: GetHtmlTextTest001
492 * @tc.desc: GetHtmlText
493 * @tc.type: FUNC
494 */
495 HWTEST_F(PasteDataRecordTest, GetHtmlTextTest001, TestSize.Level0)
496 {
497 PasteDataRecord record;
498
499 auto htmlText = record.GetHtmlText();
500 EXPECT_EQ(htmlText, nullptr);
501 }
502
503 /**
504 * @tc.name: GetHtmlTextTest002
505 * @tc.desc: GetHtmlText
506 * @tc.type: FUNC
507 */
508 HWTEST_F(PasteDataRecordTest, GetHtmlTextTest002, TestSize.Level0)
509 {
510 std::string html = html_;
511 std::shared_ptr<PasteDataRecord> record = PasteDataRecord::NewHtmlRecord(html);
512 ASSERT_NE(record, nullptr);
513
514 auto htmlText = record->GetHtmlText();
515 EXPECT_NE(htmlText, nullptr);
516 }
517
518 /**
519 * @tc.name: GetPlainTextV0Test001
520 * @tc.desc: GetPlainTextV0
521 * @tc.type: FUNC
522 */
523 HWTEST_F(PasteDataRecordTest, GetPlainTextV0Test001, TestSize.Level0)
524 {
525 std::string text = text_;
526 std::shared_ptr<PasteDataRecord> record = PasteDataRecord::NewPlainTextRecord(text);
527 ASSERT_NE(record, nullptr);
528
529 auto plainText = record->GetPlainTextV0();
530 EXPECT_NE(plainText, nullptr);
531 }
532
533 /**
534 * @tc.name: GetPlainTextV0Test002
535 * @tc.desc: GetPlainTextV0
536 * @tc.type: FUNC
537 */
538 HWTEST_F(PasteDataRecordTest, GetPlainTextV0Test002, TestSize.Level0)
539 {
540 std::string html = html_;
541 std::shared_ptr<PasteDataRecord> record = PasteDataRecord::NewHtmlRecord(html);
542 ASSERT_NE(record, nullptr);
543
544 auto plainText = record->GetPlainTextV0();
545 EXPECT_EQ(plainText, nullptr);
546 }
547
548 /**
549 * @tc.name: GetPlainTextV0Test003
550 * @tc.desc: GetPlainTextV0
551 * @tc.type: FUNC
552 */
553 HWTEST_F(PasteDataRecordTest, GetPlainTextV0Test003, TestSize.Level0)
554 {
555 std::string text = nullptr;
556 std::shared_ptr<PasteDataRecord> record = PasteDataRecord::NewPlainTextRecord(text);
557 ASSERT_NE(record, nullptr);
558
559 auto plainText = record->GetPlainTextV0();
560 EXPECT_EQ(plainText, nullptr);
561 }
562
563 /**
564 * @tc.name: GetPlainTextTest001
565 * @tc.desc: GetPlainText
566 * @tc.type: FUNC
567 */
568 HWTEST_F(PasteDataRecordTest, GetPlainTextTest001, TestSize.Level0)
569 {
570 PasteDataRecord record;
571
572 auto plainText = record.GetPlainText();
573 EXPECT_EQ(plainText, nullptr);
574 }
575
576 /**
577 * @tc.name: GetPlainTextTest002
578 * @tc.desc: GetPlainText
579 * @tc.type: FUNC
580 */
581 HWTEST_F(PasteDataRecordTest, GetPlainTextTest002, TestSize.Level0)
582 {
583 std::string text = text_;
584 std::shared_ptr<PasteDataRecord> record = PasteDataRecord::NewPlainTextRecord(text);
585 ASSERT_NE(record, nullptr);
586
587 auto plainText = record->GetPlainText();
588 EXPECT_NE(plainText, nullptr);
589 }
590
591 /**
592 * @tc.name: GetPixelMapTest001
593 * @tc.desc: GetPixelMap
594 * @tc.type: FUNC
595 */
596 HWTEST_F(PasteDataRecordTest, GetPixelMapTest001, TestSize.Level0)
597 {
598 PasteDataRecord record;
599
600 auto pixelMap = record.GetPixelMap();
601 EXPECT_EQ(pixelMap, nullptr);
602 }
603
604 /**
605 * @tc.name: GetPixelMapTest002
606 * @tc.desc: GetPixelMap
607 * @tc.type: FUNC
608 */
609 HWTEST_F(PasteDataRecordTest, GetPixelMapTest002, TestSize.Level0)
610 {
611 const uint32_t color[] = { 0x80, 0x02, 0x04, 0x08, 0x40, 0x02, 0x04, 0x08 };
612 uint32_t len = sizeof(color) / sizeof(color[0]);
613 Media::InitializationOptions opts;
614 opts.size.width = 2;
615 opts.size.height = 3;
616 opts.pixelFormat = Media::PixelFormat::UNKNOWN;
617 opts.alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
618 std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMap::Create(color, len, 0, opts.size.width, opts);
619
620 std::shared_ptr<PasteDataRecord> record = PasteDataRecord::NewPixelMapRecord(pixelMap);
621 ASSERT_NE(record, nullptr);
622
623 pixelMap = record->GetPixelMap();
624 EXPECT_NE(pixelMap, nullptr);
625 }
626
627 /**
628 * @tc.name: GetUriV0Test001
629 * @tc.desc: GetUriV0
630 * @tc.type: FUNC
631 */
632 HWTEST_F(PasteDataRecordTest, GetUriV0Test001, TestSize.Level0)
633 {
634 OHOS::Uri uri(uri_);
635 std::shared_ptr<PasteDataRecord> record = PasteDataRecord::NewUriRecord(uri);
636 ASSERT_NE(record, nullptr);
637
638 auto tempUri = record->GetUriV0();
639 EXPECT_NE(tempUri, nullptr);
640 }
641
642 /**
643 * @tc.name: GetUriV0Test002
644 * @tc.desc: GetUriV0
645 * @tc.type: FUNC
646 */
647 HWTEST_F(PasteDataRecordTest, GetUriV0Test002, TestSize.Level0)
648 {
649 std::string html = html_;
650 std::shared_ptr<PasteDataRecord> record = PasteDataRecord::NewHtmlRecord(html);
651 ASSERT_NE(record, nullptr);
652
653 auto tempUri = record->GetUriV0();
654 EXPECT_EQ(tempUri, nullptr);
655 }
656
657 /**
658 * @tc.name: GetUriV0Test003
659 * @tc.desc: GetUriV0
660 * @tc.type: FUNC
661 */
662 HWTEST_F(PasteDataRecordTest, GetUriV0Test003, TestSize.Level0)
663 {
664 PasteDataRecord record;
665 record.SetUri(nullptr);
666
667 auto tempUri = record.GetUriV0();
668 EXPECT_EQ(tempUri, nullptr);
669 }
670
671 /**
672 * @tc.name: GetUriTest001
673 * @tc.desc: GetUri
674 * @tc.type: FUNC
675 */
676 HWTEST_F(PasteDataRecordTest, GetUriTest001, TestSize.Level0)
677 {
678 OHOS::Uri uri(uri_);
679 std::shared_ptr<PasteDataRecord> record = PasteDataRecord::NewUriRecord(uri);
680 ASSERT_NE(record, nullptr);
681
682 auto tempUri = record->GetUri();
683 EXPECT_NE(tempUri, nullptr);
684 }
685
686 /**
687 * @tc.name: GetUriTest002
688 * @tc.desc: GetUri
689 * @tc.type: FUNC
690 */
691 HWTEST_F(PasteDataRecordTest, GetUriTest002, TestSize.Level0)
692 {
693 PasteDataRecord record;
694 record.SetUri(nullptr);
695
696 auto tempUri = record.GetUri();
697 EXPECT_EQ(tempUri, nullptr);
698 }
699
700 /**
701 * @tc.name: ConstructorTest001
702 * @tc.desc: PasteDataRecord::PasteDataRecord
703 * @tc.type: FUNC
704 */
705 HWTEST_F(PasteDataRecordTest, ConstructorTest001, TestSize.Level0)
706 {
707 PasteDataRecord record("", nullptr, nullptr, nullptr, nullptr);
708 auto pixelMap = record.GetPixelMapV0();
709 EXPECT_EQ(pixelMap, nullptr);
710 }
711
712 /**
713 * @tc.name: AddEntryTest002
714 * @tc.desc: AddEntry & GetEntry
715 * @tc.type: FUNC
716 */
717 HWTEST_F(PasteDataRecordTest, AddEntryTest002, TestSize.Level0)
718 {
719 PasteDataRecord record;
720 record.AddEntry("1", nullptr);
721
722 auto plainTextUtdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
723 auto object = std::make_shared<Object>();
724 object->value_[UDMF::UNIFORM_DATA_TYPE] = plainTextUtdId;
725 object->value_[UDMF::CONTENT] = text_;
726 auto fileUriUtdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI);
727 auto entry = std::make_shared<PasteDataEntry>(plainTextUtdId, object);
728 record.AddEntry(fileUriUtdId, entry);
729
730 auto ret = record.GetEntry(plainTextUtdId);
731 EXPECT_EQ(ret, nullptr);
732 }
733
734 /**
735 * @tc.name: AddEntryTest003
736 * @tc.desc: AddEntry & GetEntry
737 * @tc.type: FUNC
738 */
739 HWTEST_F(PasteDataRecordTest, AddEntryTest003, TestSize.Level0)
740 {
741 PasteDataRecord record(MIMETYPE_TEXT_WANT, nullptr, nullptr, nullptr, nullptr);
742 auto wantUtdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::OPENHARMONY_WANT);
743 auto object = std::make_shared<Object>();
744 object->value_[UDMF::UNIFORM_DATA_TYPE] = wantUtdId;
745 auto entry = std::make_shared<PasteDataEntry>(wantUtdId, object);
746 record.AddEntry(wantUtdId, entry);
747
748 auto ret = record.GetEntry(wantUtdId);
749 EXPECT_NE(ret, nullptr);
750 }
751
752 /**
753 * @tc.name: AddEntryTest004
754 * @tc.desc: AddEntry & GetEntry
755 * @tc.type: FUNC
756 */
757 HWTEST_F(PasteDataRecordTest, AddEntryTest004, TestSize.Level0)
758 {
759 PasteDataRecord record(MIMETYPE_TEXT_WANT, nullptr, nullptr, nullptr, nullptr);
760 AddLinkUdsEntry(record);
761 auto ret = record.GetEntry(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK));
762 EXPECT_NE(ret, nullptr);
763
764 ret = record.GetEntry(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE));
765 EXPECT_EQ(ret, nullptr);
766
767 AddFileUriUdsEntry(record);
768 ret = record.GetEntry(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE));
769 EXPECT_NE(ret, nullptr);
770 }
771
772 /**
773 * @tc.name: SetTextContentTest001
774 * @tc.desc: SetTextContent & GetTextContent
775 * @tc.type: FUNC
776 */
777 HWTEST_F(PasteDataRecordTest, SetTextContentTest001, TestSize.Level0)
778 {
779 PasteDataRecord record;
780 std::string ret = record.GetTextContent();
781 EXPECT_STREQ(ret.c_str(), "");
782
783 record.SetTextContent(text_);
784 ret = record.GetTextContent();
785 EXPECT_STREQ(ret.c_str(), text_.c_str());
786 }
787
788 /**
789 * @tc.name: GetValidMimeTypesTest001
790 * @tc.desc: GetValidMimeTypes
791 * @tc.type: FUNC
792 */
793 HWTEST_F(PasteDataRecordTest, GetValidMimeTypesTest001, TestSize.Level0)
794 {
795 PasteDataRecord record(MIMETYPE_TEXT_WANT, nullptr, nullptr, nullptr, nullptr);
796 std::vector<std::string> mimeTypes = { MIMETYPE_TEXT_WANT, MIMETYPE_TEXT_URI };
797 std::vector<std::string> validTypes = record.GetValidMimeTypes(mimeTypes);
798 EXPECT_NE(validTypes.size(), 0);
799 }
800
801 /**
802 * @tc.name: AddEntryByMimeTypeTest001
803 * @tc.desc: AddEntryByMimeType & GetEntryByMimeType
804 * @tc.type: FUNC
805 */
806 HWTEST_F(PasteDataRecordTest, AddEntryByMimeTypeTest001, TestSize.Level0)
807 {
808 PasteDataRecord record;
809 std::string mimeType = "";
810 record.AddEntryByMimeType(mimeType, nullptr);
811
812 auto ret = record.GetEntryByMimeType(mimeType);
813 EXPECT_EQ(ret, nullptr);
814 }
815
816 /**
817 * @tc.name: AddEntryByMimeTypeTest002
818 * @tc.desc: AddEntryByMimeType & GetEntryByMimeType
819 * @tc.type: FUNC
820 */
821 HWTEST_F(PasteDataRecordTest, AddEntryByMimeTypeTest002, TestSize.Level0)
822 {
823 PasteDataRecord record;
824 auto entry = std::make_shared<PasteDataEntry>();
825 record.AddEntryByMimeType(MIMETYPE_TEXT_PLAIN, entry);
826
827 auto ret = record.GetEntryByMimeType(MIMETYPE_TEXT_PLAIN);
828 EXPECT_NE(ret, nullptr);
829 }
830
831 /**
832 * @tc.name: AddEntryByMimeTypeTest003
833 * @tc.desc: AddEntryByMimeType & GetMimeTypes
834 * @tc.type: FUNC
835 */
836 HWTEST_F(PasteDataRecordTest, AddEntryByMimeTypeTest003, TestSize.Level0)
837 {
838 PasteDataRecord record(MIMETYPE_TEXT_PLAIN, nullptr, nullptr, nullptr, nullptr);
839 AddPlainUdsEntry(record);
840
841 std::set<std::string> mimeTypes = record.GetMimeTypes();
842 bool isExist = mimeTypes.find(MIMETYPE_TEXT_PLAIN) == mimeTypes.end();
843 EXPECT_FALSE(isExist);
844 }
845
846 /**
847 * @tc.name: AddEntryByMimeTypeTest004
848 * @tc.desc: AddEntryByMimeType & GetEntryByMimeType
849 * @tc.type: FUNC
850 */
851 HWTEST_F(PasteDataRecordTest, AddEntryByMimeTypeTest004, TestSize.Level0)
852 {
853 PasteDataRecord record(MIMETYPE_TEXT_PLAIN, nullptr, nullptr, nullptr, nullptr);
854 auto plainTextUtdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
855 auto object = std::make_shared<Object>();
856 object->value_[UDMF::UNIFORM_DATA_TYPE] = plainTextUtdId;
857 object->value_[UDMF::CONTENT] = text_;
858 auto entry = std::make_shared<PasteDataEntry>(plainTextUtdId, object);
859
860 record.AddEntryByMimeType(MIMETYPE_TEXT_PLAIN, entry);
861 auto ret = record.GetEntryByMimeType(MIMETYPE_TEXT_PLAIN);
862 EXPECT_NE(ret, nullptr);
863
864 AddHtmlUdsEntry(record);
865 std::set<std::string> mimeTypes = record.GetMimeTypes();
866 bool isExist = mimeTypes.find(MIMETYPE_TEXT_PLAIN) == mimeTypes.end();
867 EXPECT_FALSE(isExist);
868 }
869
870 /**
871 * @tc.name: HasEmptyEntryTest001
872 * @tc.desc: HasEmptyEntry
873 * @tc.type: FUNC
874 */
875 HWTEST_F(PasteDataRecordTest, HasEmptyEntryTest001, TestSize.Level0)
876 {
877 PasteDataRecord record;
878 auto entries = record.GetEntries();
879 EXPECT_EQ(entries.size(), 0);
880
881 bool ret = record.HasEmptyEntry();
882 EXPECT_FALSE(ret);
883 }
884
885 /**
886 * @tc.name: HasEmptyEntryTest002
887 * @tc.desc: HasEmptyEntry
888 * @tc.type: FUNC
889 */
890 HWTEST_F(PasteDataRecordTest, HasEmptyEntryTest002, TestSize.Level0)
891 {
892 PasteDataRecord record;
893 auto entry = std::make_shared<PasteDataEntry>();
894 std::string utdId = "general.hyperlink";
895 entry->SetUtdId(utdId);
896 record.AddEntry(utdId, entry);
897 auto entries = record.GetEntries();
898 EXPECT_EQ(entries.size(), 1);
899
900 bool ret = record.HasEmptyEntry();
901 EXPECT_TRUE(ret);
902 }
903
904 /**
905 * @tc.name: GetUDMFValueTest001
906 * @tc.desc: SetUDMFValue & GetUDMFValue
907 * @tc.type: FUNC
908 */
909 HWTEST_F(PasteDataRecordTest, GetUDMFValueTest001, TestSize.Level0)
910 {
911 PasteDataRecord record1("1", nullptr, nullptr, nullptr, nullptr);
912 auto entries = record1.GetEntries();
913 EXPECT_EQ(entries.size(), 0);
914
915 auto customData = std::make_shared<MineCustomData>();
916 PasteDataRecord::Builder builder("1");
917 builder.SetCustomData(customData);
918 auto record2 = builder.Build();
919 ASSERT_NE(record2, nullptr);
920 entries = record2->GetEntries();
921 EXPECT_EQ(entries.size(), 0);
922 }
923
924 /**
925 * @tc.name: GetUDMFValueTest002
926 * @tc.desc: GetUDMFValue
927 * @tc.type: FUNC
928 */
929 HWTEST_F(PasteDataRecordTest, GetUDMFValueTest002, TestSize.Level0)
930 {
931 PasteDataRecord record1(MIMETYPE_PIXELMAP, nullptr, nullptr, nullptr, nullptr);
932 auto entries = record1.GetEntries();
933 EXPECT_EQ(entries.size(), 0);
934
935 const uint32_t color[] = { 0x80, 0x02, 0x04, 0x08, 0x40, 0x02, 0x04, 0x08 };
936 uint32_t len = sizeof(color) / sizeof(color[0]);
937 Media::InitializationOptions opts;
938 opts.size.width = 2;
939 opts.size.height = 3;
940 opts.pixelFormat = Media::PixelFormat::UNKNOWN;
941 opts.alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
942 std::shared_ptr<OHOS::Media::PixelMap> pixelMap = Media::PixelMap::Create(color, len, 0, opts.size.width, opts);
943
944 PasteDataRecord::Builder builder(MIMETYPE_PIXELMAP);
945 builder.SetPixelMap(pixelMap);
946 auto record2 = builder.Build();
947 ASSERT_NE(record2, nullptr);
948 entries = record2->GetEntries();
949 EXPECT_EQ(entries.size(), 1);
950 }
951
952 /**
953 * @tc.name: IsDelayRecordTest
954 * @tc.desc: IsDelayRecord
955 * @tc.type: FUNC
956 */
957 HWTEST_F(PasteDataRecordTest, IsDelayRecordTest, TestSize.Level0)
958 {
959 PasteDataRecord record(MIMETYPE_TEXT_WANT, nullptr, nullptr, nullptr, nullptr);
960 record.SetDelayRecordFlag(true);
961 EXPECT_TRUE(record.IsDelayRecord());
962 record.SetDelayRecordFlag(false);
963 EXPECT_FALSE(record.IsDelayRecord());
964 }
965
966 /**
967 * @tc.name: GetEntryByMimeType001
968 * @tc.desc: GetEntryByMimeType(MIMETYPE_TEXT_WANT)
969 * @tc.type: FUNC
970 */
971 HWTEST_F(PasteDataRecordTest, GetEntryByMimeType001, TestSize.Level0)
972 {
973 std::shared_ptr<AAFwk::Want> want = std::make_shared<AAFwk::Want>();
974 want->SetUri(uri_);
975 std::shared_ptr<PasteDataRecord> record = PasteDataRecord::NewWantRecord(want);
976 ASSERT_NE(record, nullptr);
977 std::shared_ptr<PasteDataEntry> entry = record->GetEntryByMimeType(MIMETYPE_TEXT_WANT);
978 ASSERT_NE(entry, nullptr);
979 std::shared_ptr<AAFwk::Want> converted = entry->ConvertToWant();
980 ASSERT_NE(converted, nullptr);
981 EXPECT_EQ(converted->ToString(), want->ToString());
982 }
983
984 /**
985 * @tc.name: GetEntryByMimeType002
986 * @tc.desc: GetEntryByMimeType(MIMETYPE_TEXT_PLAIN)
987 * @tc.type: FUNC
988 */
989 HWTEST_F(PasteDataRecordTest, GetEntryByMimeType002, TestSize.Level0)
990 {
991 std::string text = text_;
992 std::shared_ptr<PasteDataRecord> record = PasteDataRecord::NewPlainTextRecord(text);
993 ASSERT_NE(record, nullptr);
994 std::shared_ptr<PasteDataEntry> entry = record->GetEntryByMimeType(MIMETYPE_TEXT_PLAIN);
995 ASSERT_NE(entry, nullptr);
996 std::shared_ptr<std::string> converted = entry->ConvertToPlainText();
997 ASSERT_NE(converted, nullptr);
998 EXPECT_EQ(*converted, text);
999 }
1000
1001 /**
1002 * @tc.name: GetEntryByMimeType003
1003 * @tc.desc: GetEntryByMimeType(MIMETYPE_TEXT_HTML)
1004 * @tc.type: FUNC
1005 */
1006 HWTEST_F(PasteDataRecordTest, GetEntryByMimeType003, TestSize.Level0)
1007 {
1008 std::string html = html_;
1009 std::shared_ptr<PasteDataRecord> record = PasteDataRecord::NewHtmlRecord(html);
1010 ASSERT_NE(record, nullptr);
1011 std::shared_ptr<PasteDataEntry> entry = record->GetEntryByMimeType(MIMETYPE_TEXT_HTML);
1012 ASSERT_NE(entry, nullptr);
1013 std::shared_ptr<std::string> converted = entry->ConvertToHtml();
1014 ASSERT_NE(converted, nullptr);
1015 EXPECT_EQ(*converted, html);
1016 }
1017
1018 /**
1019 * @tc.name: GetEntryByMimeType004
1020 * @tc.desc: GetEntryByMimeType(MIMETYPE_TEXT_URI)
1021 * @tc.type: FUNC
1022 */
1023 HWTEST_F(PasteDataRecordTest, GetEntryByMimeType004, TestSize.Level0)
1024 {
1025 OHOS::Uri uri(uri_);
1026 std::shared_ptr<PasteDataRecord> record = PasteDataRecord::NewUriRecord(uri);
1027 ASSERT_NE(record, nullptr);
1028 std::shared_ptr<PasteDataEntry> entry = record->GetEntryByMimeType(MIMETYPE_TEXT_URI);
1029 ASSERT_NE(entry, nullptr);
1030 std::shared_ptr<OHOS::Uri> converted = entry->ConvertToUri();
1031 ASSERT_NE(converted, nullptr);
1032 EXPECT_EQ(converted->ToString(), uri.ToString());
1033 }
1034
1035 /**
1036 * @tc.name: GetEntryByMimeType005
1037 * @tc.desc: GetEntryByMimeType(MIMETYPE_PIXELMAP)
1038 * @tc.type: FUNC
1039 */
1040 HWTEST_F(PasteDataRecordTest, GetEntryByMimeType005, TestSize.Level0)
1041 {
1042 const uint32_t color[] = { 0x80, 0x02, 0x04, 0x08, 0x40, 0x02, 0x04, 0x08 };
1043 uint32_t len = sizeof(color) / sizeof(color[0]);
1044 Media::InitializationOptions opts;
1045 opts.size.width = 2;
1046 opts.size.height = 3;
1047 opts.pixelFormat = Media::PixelFormat::UNKNOWN;
1048 opts.alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
1049 std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMap::Create(color, len, 0, opts.size.width, opts);
1050
1051 std::shared_ptr<PasteDataRecord> record = PasteDataRecord::NewPixelMapRecord(pixelMap);
1052 ASSERT_NE(record, nullptr);
1053 std::shared_ptr<PasteDataEntry> entry = record->GetEntryByMimeType(MIMETYPE_PIXELMAP);
1054 ASSERT_NE(entry, nullptr);
1055 std::shared_ptr<Media::PixelMap> converted = entry->ConvertToPixelMap();
1056 ASSERT_NE(converted, nullptr);
1057 EXPECT_EQ(converted->GetWidth(), pixelMap->GetWidth());
1058 EXPECT_EQ(converted->GetHeight(), pixelMap->GetHeight());
1059 }
1060
1061 /**
1062 * @tc.name: GetEntryByMimeType006
1063 * @tc.desc: GetEntryByMimeType(custom)
1064 * @tc.type: FUNC
1065 */
1066 HWTEST_F(PasteDataRecordTest, GetEntryByMimeType006, TestSize.Level0)
1067 {
1068 std::string key = "openharmony.styled-string";
1069 std::vector<uint8_t> val = {0x01, 0x02, 0x03};
1070 auto customData = std::make_shared<MineCustomData>();
1071 customData->AddItemData(key, val);
1072
1073 std::string htmlStr = "<p>hello</p>";
1074 PasteDataRecord::Builder builder(MIMETYPE_TEXT_HTML);
1075 builder.SetHtmlText(std::make_shared<std::string>(htmlStr));
1076 builder.SetCustomData(customData);
1077
1078 auto record = builder.Build();
1079 ASSERT_NE(record, nullptr);
1080
1081 auto entry = record->GetEntryByMimeType(MIMETYPE_TEXT_HTML);
1082 ASSERT_NE(entry, nullptr);
1083 std::shared_ptr<std::string> html = entry->ConvertToHtml();
1084 ASSERT_NE(html, nullptr);
1085 EXPECT_STREQ(html->c_str(), htmlStr.c_str());
1086
1087 entry = record->GetEntryByMimeType(key);
1088 ASSERT_NE(entry, nullptr);
1089 customData = entry->ConvertToCustomData();
1090 ASSERT_NE(customData, nullptr);
1091 auto itemData = customData->GetItemData();
1092 auto item = itemData.find(key);
1093 ASSERT_NE(item, itemData.end());
1094 std::vector<uint8_t> dataArray = item->second;
1095 EXPECT_EQ(dataArray, val);
1096 }
1097
1098 /**
1099 * @tc.name: GetEntryByMimeType007
1100 * @tc.desc: GetEntryByMimeType(custom)
1101 * @tc.type: FUNC
1102 */
1103 HWTEST_F(PasteDataRecordTest, GetEntryByMimeType007, TestSize.Level0)
1104 {
1105 std::string key = "openharmony.styled-string";
1106 std::vector<uint8_t> val = {0x01, 0x02, 0x03};
1107 auto customData = std::make_shared<MineCustomData>();
1108 customData->AddItemData(key, val);
1109
1110 PasteDataRecord::Builder builder(key);
1111 builder.SetCustomData(customData);
1112 auto record = builder.Build();
1113 ASSERT_NE(record, nullptr);
1114
1115 auto entry = record->GetEntryByMimeType(key);
1116 ASSERT_NE(entry, nullptr);
1117 customData = entry->ConvertToCustomData();
1118 ASSERT_NE(customData, nullptr);
1119 auto itemData = customData->GetItemData();
1120 auto item = itemData.find(key);
1121 ASSERT_NE(item, itemData.end());
1122 std::vector<uint8_t> dataArray = item->second;
1123 EXPECT_EQ(dataArray, val);
1124 }
1125
1126 /**
1127 * @tc.name: GetPassUriTest001
1128 * @tc.desc:
1129 * @tc.type: FUNC
1130 * @tc.require:
1131 * @tc.author:
1132 */
1133 HWTEST_F(PasteDataRecordTest, GetPassUriTest001, TestSize.Level0)
1134 {
1135 PasteDataRecord record;
1136 record.convertUri_ = "convertUri";
1137 EXPECT_EQ(record.GetPassUri(), "convertUri");
1138 }
1139
1140 /**
1141 * @tc.name: GetPassUriTest002
1142 * @tc.desc:
1143 * @tc.type: FUNC
1144 * @tc.require:
1145 * @tc.author:
1146 */
1147 HWTEST_F(PasteDataRecordTest, GetPassUriTest002, TestSize.Level0)
1148 {
1149 PasteDataRecord record;
1150 EXPECT_EQ(record.GetPassUri(), "");
1151 }
1152
1153 /**
1154 * @tc.name: EncodeRemoteTest001
1155 * @tc.desc: test encode & decode remote plain-text
1156 * @tc.type: FUNC
1157 */
1158 HWTEST_F(PasteDataRecordTest, EncodeRemoteTest001, TestSize.Level0)
1159 {
1160 PasteDataRecord obj1;
1161 auto udmfObject = std::make_shared<Object>();
1162 std::string utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
1163 udmfObject->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
1164 udmfObject->value_[UDMF::CONTENT] = "content";
1165 auto entry1 = std::make_shared<PasteDataEntry>();
1166 entry1->SetValue(udmfObject);
1167 entry1->SetUtdId(utdId);
1168 entry1->SetMimeType(MIMETYPE_TEXT_PLAIN);
1169 obj1.AddEntry(utdId, entry1);
1170
1171 std::vector<uint8_t> buffer;
1172 bool ret = obj1.Encode(buffer, true);
1173 ASSERT_TRUE(ret);
1174
1175 PasteDataRecord obj2;
1176 ret = obj2.Decode(buffer);
1177 ASSERT_TRUE(ret);
1178
1179 EXPECT_EQ(obj1.GetMimeType(), obj2.GetMimeType());
1180 auto entry2 = obj2.GetEntry(utdId);
1181 ASSERT_NE(entry2, nullptr);
1182 auto entryValue = entry2->GetValue();
1183 ASSERT_TRUE(std::holds_alternative<std::shared_ptr<Object>>(entryValue));
1184 auto udmfObject2 = std::get<std::shared_ptr<Object>>(entryValue);
1185 ASSERT_NE(udmfObject2, nullptr);
1186 EXPECT_EQ(udmfObject->value_, udmfObject2->value_);
1187 }
1188
1189 /**
1190 * @tc.name: EncodeRemoteTest002
1191 * @tc.desc: test encode & decode remote html
1192 * @tc.type: FUNC
1193 */
1194 HWTEST_F(PasteDataRecordTest, EncodeRemoteTest002, TestSize.Level0)
1195 {
1196 PasteDataRecord obj1;
1197 auto udmfObject = std::make_shared<Object>();
1198 std::string utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML);
1199 udmfObject->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
1200 udmfObject->value_[UDMF::HTML_CONTENT] = "html content";
1201 udmfObject->value_[UDMF::PLAIN_CONTENT] = "text content";
1202 auto entry1 = std::make_shared<PasteDataEntry>();
1203 entry1->SetValue(udmfObject);
1204 entry1->SetUtdId(utdId);
1205 entry1->SetMimeType(MIMETYPE_TEXT_HTML);
1206 obj1.AddEntry(utdId, entry1);
1207
1208 std::vector<uint8_t> buffer;
1209 bool ret = obj1.Encode(buffer, true);
1210 ASSERT_TRUE(ret);
1211
1212 PasteDataRecord obj2;
1213 ret = obj2.Decode(buffer);
1214 ASSERT_TRUE(ret);
1215
1216 EXPECT_EQ(obj1.GetMimeType(), obj2.GetMimeType());
1217 auto entry2 = obj2.GetEntry(utdId);
1218 ASSERT_NE(entry2, nullptr);
1219 auto entryValue = entry2->GetValue();
1220 ASSERT_TRUE(std::holds_alternative<std::shared_ptr<Object>>(entryValue));
1221 auto udmfObject2 = std::get<std::shared_ptr<Object>>(entryValue);
1222 ASSERT_NE(udmfObject2, nullptr);
1223 EXPECT_EQ(udmfObject->value_, udmfObject2->value_);
1224 }
1225
1226 /**
1227 * @tc.name: EncodeRemoteTest003
1228 * @tc.desc: test encode & decode remote uri
1229 * @tc.type: FUNC
1230 */
1231 HWTEST_F(PasteDataRecordTest, EncodeRemoteTest003, TestSize.Level0)
1232 {
1233 std::string uri = "file://content";
1234 PasteDataRecord obj1;
1235 auto udmfObject = std::make_shared<Object>();
1236 std::string utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI);
1237 udmfObject->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
1238 udmfObject->value_[UDMF::FILE_URI_PARAM] = uri;
1239 auto entry1 = std::make_shared<PasteDataEntry>();
1240 entry1->SetValue(udmfObject);
1241 entry1->SetUtdId(utdId);
1242 entry1->SetMimeType(MIMETYPE_TEXT_URI);
1243 obj1.AddEntry(utdId, entry1);
1244
1245 std::vector<uint8_t> buffer;
1246 bool ret = obj1.Encode(buffer, true);
1247 ASSERT_TRUE(ret);
1248
1249 PasteDataRecord obj2;
1250 ret = obj2.Decode(buffer);
1251 ASSERT_TRUE(ret);
1252
1253 EXPECT_EQ(obj1.GetMimeType(), obj2.GetMimeType());
1254 auto entry2 = obj2.GetEntry(utdId);
1255 ASSERT_NE(entry2, nullptr);
1256 auto uri2 = entry2->ConvertToUri();
1257 ASSERT_NE(uri2, nullptr);
1258 EXPECT_STREQ(uri.c_str(), uri2->ToString().c_str());
1259 }
1260
1261 /**
1262 * @tc.name: EncodeRemoteTest004
1263 * @tc.desc: test encode & decode remote pixelMap
1264 * @tc.type: FUNC
1265 */
1266 HWTEST_F(PasteDataRecordTest, EncodeRemoteTest004, TestSize.Level0)
1267 {
1268 const uint32_t color[] = { 0x80, 0x02, 0x04, 0x08, 0x40, 0x02, 0x04, 0x08 };
1269 uint32_t len = sizeof(color) / sizeof(color[0]);
1270 Media::InitializationOptions opts;
1271 opts.size.width = 2;
1272 opts.size.height = 3;
1273 opts.pixelFormat = Media::PixelFormat::UNKNOWN;
1274 opts.alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
1275 std::shared_ptr<OHOS::Media::PixelMap> pixelMap = Media::PixelMap::Create(color, len, 0, opts.size.width, opts);
1276
1277 PasteDataRecord obj1;
1278 auto udmfObject = std::make_shared<Object>();
1279 std::string utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP);
1280 udmfObject->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
1281 udmfObject->value_[UDMF::PIXEL_MAP] = pixelMap;
1282 auto entry1 = std::make_shared<PasteDataEntry>();
1283 entry1->SetValue(udmfObject);
1284 entry1->SetUtdId(utdId);
1285 entry1->SetMimeType(MIMETYPE_PIXELMAP);
1286 obj1.AddEntry(utdId, entry1);
1287
1288 std::vector<uint8_t> buffer;
1289 bool ret = obj1.Encode(buffer, true);
1290 ASSERT_TRUE(ret);
1291
1292 PasteDataRecord obj2;
1293 ret = obj2.Decode(buffer);
1294 ASSERT_TRUE(ret);
1295
1296 EXPECT_EQ(obj1.GetMimeType(), obj2.GetMimeType());
1297 auto entry2 = obj2.GetEntry(utdId);
1298 ASSERT_NE(entry2, nullptr);
1299 auto pixelMap2 = entry2->ConvertToPixelMap();
1300 ASSERT_NE(pixelMap2, nullptr);
1301 EXPECT_TRUE(pixelMap->IsSameImage(*pixelMap2));
1302 }
1303
1304 /**
1305 * @tc.name: EncodeRemoteTest005
1306 * @tc.desc: test encode & decode remote want
1307 * @tc.type: FUNC
1308 */
1309 HWTEST_F(PasteDataRecordTest, EncodeRemoteTest005, TestSize.Level0)
1310 {
1311 std::shared_ptr<AAFwk::Want> want = std::make_shared<AAFwk::Want>();
1312 want->SetUri(uri_);
1313
1314 PasteDataRecord obj1;
1315 std::string utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::OPENHARMONY_WANT);
1316 auto entry1 = std::make_shared<PasteDataEntry>();
1317 entry1->SetValue(want);
1318 entry1->SetUtdId(utdId);
1319 entry1->SetMimeType(MIMETYPE_TEXT_WANT);
1320 obj1.AddEntry(utdId, entry1);
1321
1322 std::vector<uint8_t> buffer;
1323 bool ret = obj1.Encode(buffer, true);
1324 ASSERT_TRUE(ret);
1325
1326 PasteDataRecord obj2;
1327 ret = obj2.Decode(buffer);
1328 ASSERT_TRUE(ret);
1329
1330 EXPECT_EQ(obj1.GetMimeType(), obj2.GetMimeType());
1331 auto entry2 = obj2.GetEntry(utdId);
1332 ASSERT_NE(entry2, nullptr);
1333 auto entryValue = entry2->GetValue();
1334 ASSERT_TRUE(std::holds_alternative<std::shared_ptr<AAFwk::Want>>(entryValue));
1335 auto want2 = std::get<std::shared_ptr<AAFwk::Want>>(entryValue);
1336 ASSERT_NE(want2, nullptr);
1337 EXPECT_STREQ(want2->ToString().c_str(), want->ToString().c_str());
1338 }
1339
1340 /**
1341 * @tc.name: EncodeRemoteTest006
1342 * @tc.desc: test encode & decode remote custom
1343 * @tc.type: FUNC
1344 */
1345 HWTEST_F(PasteDataRecordTest, EncodeRemoteTest006, TestSize.Level0)
1346 {
1347 std::string mimeType = "openharmony.styled-string";
1348 std::vector<uint8_t> array = {0x01, 0x02, 0x03};
1349 auto customData = std::make_shared<MineCustomData>();
1350 customData->AddItemData(mimeType, array);
1351
1352 PasteDataRecord::Builder builder(mimeType);
1353 builder.SetCustomData(customData);
1354
1355 auto obj1 = builder.Build();
1356 ASSERT_NE(obj1, nullptr);
1357
1358 std::vector<uint8_t> buffer;
1359 bool ret = obj1->Encode(buffer, true);
1360 ASSERT_TRUE(ret);
1361
1362 PasteDataRecord obj2;
1363 ret = obj2.Decode(buffer);
1364 ASSERT_TRUE(ret);
1365
1366 EXPECT_EQ(obj1->GetMimeType(), obj2.GetMimeType());
1367 auto entry2 = obj2.GetEntryByMimeType(mimeType);
1368 ASSERT_NE(entry2, nullptr);
1369 auto entryValue = entry2->GetValue();
1370 ASSERT_TRUE(std::holds_alternative<std::vector<uint8_t>>(entryValue));
1371 auto array2 = std::get<std::vector<uint8_t>>(entryValue);
1372 EXPECT_EQ(array2, array);
1373 }
1374
1375 /**
1376 * @tc.name: AddUriEntryTest001
1377 * @tc.desc: AddUriEntryTest001
1378 * @tc.type: FUNC
1379 * @tc.require:entries
1380 * @tarowang
1381 */
1382 HWTEST_F(PasteDataRecordTest, AddUriEntryTest001, TestSize.Level2)
1383 {
1384 auto tempPasteboard = std::make_shared<PasteDataRecord>();
1385 EXPECT_NE(tempPasteboard, nullptr);
1386
1387 tempPasteboard->AddUriEntry();
1388 }
1389
1390 /**
1391 * @tc.name: NewMultiTypeRecordTest002
1392 * @tc.desc: NewMultiTypeRecordTest002
1393 * @tc.type: FUNC
1394 * @tc.require:entries
1395 * @tarowang
1396 */
1397 HWTEST_F(PasteDataRecordTest, NewMultiTypeRecordTest002, TestSize.Level2)
1398 {
1399 std::shared_ptr<std::map<std::string, std::shared_ptr<EntryValue>>>values = nullptr;
1400 std::string recordMimeType = "text/pain";
1401
1402 auto result = PasteDataRecord::NewMultiTypeRecord(values, recordMimeType);
1403 EXPECT_NE(result, nullptr);
1404 EXPECT_TRUE(result->GetEntries().empty());
1405 }
1406
1407 /**
1408 * @tc.name: NewMultiTypeRecordTest003
1409 * @tc.desc: NewMultiTypeRecordTest003
1410 * @tc.type: FUNC
1411 * @tc.require:entries
1412 * @tarowang
1413 */
1414 HWTEST_F(PasteDataRecordTest, NewMultiTypeRecordTest003, TestSize.Level2)
1415 {
1416
1417 auto values = std::make_shared<std::map<std::string, std::shared_ptr<EntryValue>>>();
1418 std::string recordMimeType = "";
1419
1420 auto result = PasteDataRecord::NewMultiTypeRecord(values, recordMimeType);
1421 EXPECT_NE(result, nullptr);
1422 EXPECT_TRUE(result->GetEntries().empty());
1423 }
1424
1425 /**
1426 * @tc.name: DecodeTLVTest001
1427 * @tc.desc: DecodeTLVTest001
1428 * @tc.type: FUNC
1429 * @tc.require:entries
1430 * @tarowang
1431 */
1432 HWTEST_F(PasteDataRecordTest, DecodeTLVTest001, TestSize.Level2)
1433 {
1434 std::shared_ptr<PasteDataRecord> record = std::make_shared<PasteDataRecord>();
1435 EXPECT_NE(record, nullptr);
1436 std::vector<std::uint8_t> buffer;
1437 ReadOnlyBuffer buff(buffer);
1438 bool ret = record->DecodeTLV(buff);
1439
1440 EXPECT_EQ(ret, true);
1441 }
1442 } // namespace OHOS::MiscServices
1443