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 "convert_utils.h"
19 #include "unified_meta.h"
20
21 namespace OHOS::MiscServices {
22 using namespace testing::ext;
23 using namespace testing;
24 using namespace OHOS::Media;
25 using UDType = UDMF::UDType;
26 class PasteDataEntryTest : 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 PasteDataEntry InitPlainTextEntry();
35 PasteDataEntry InitPixelMapEntry();
36 PasteDataEntry InitUriEntry();
37 PasteDataEntry InitWantEntry();
38 PasteDataEntry InitHtmlEntry();
39 void CheckPlainUds(std::shared_ptr<PasteDataEntry> entry);
40 void CheckPixelMapUds(std::shared_ptr<PasteDataEntry> entry);
41 std::string text_ = "test_string";
42 std::string uri_ = "file://test_uri";
43 std::string html_ = "<div class='disable'>helloWorld</div>";
44 int32_t width_ = 5;
45 int32_t height_ = 7;
46 };
47
SetUpTestCase(void)48 void PasteDataEntryTest::SetUpTestCase(void) { }
49
TearDownTestCase(void)50 void PasteDataEntryTest::TearDownTestCase(void) { }
51
SetUp(void)52 void PasteDataEntryTest::SetUp(void) { }
53
TearDown(void)54 void PasteDataEntryTest::TearDown(void) { }
55
InitPlainTextEntry()56 PasteDataEntry PasteDataEntryTest::InitPlainTextEntry()
57 {
58 auto udsObject = std::make_shared<Object>();
59 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
60 udsObject->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
61 udsObject->value_[UDMF::CONTENT] = text_;
62 return { utdId, udsObject };
63 }
64
InitUriEntry()65 PasteDataEntry PasteDataEntryTest::InitUriEntry()
66 {
67 auto udsObject = std::make_shared<Object>();
68 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI);
69 udsObject->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
70 udsObject->value_[UDMF::FILE_URI_PARAM] = uri_;
71 udsObject->value_[UDMF::FILE_TYPE] = "";
72 return { utdId, udsObject };
73 }
74
InitWantEntry()75 PasteDataEntry PasteDataEntryTest::InitWantEntry()
76 {
77 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::OPENHARMONY_WANT);
78 using namespace OHOS::AAFwk;
79 std::shared_ptr<Want> want = std::make_shared<Want>();
80 std::string idKey = "id";
81 int32_t idValue = 123;
82 std::string deviceKey = "deviceId_key";
83 want->SetParam(idKey, idValue);
84 return { utdId, want };
85 }
86
InitHtmlEntry()87 PasteDataEntry PasteDataEntryTest::InitHtmlEntry()
88 {
89 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML);
90 auto udsObject = std::make_shared<Object>();
91 udsObject->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
92 udsObject->value_[UDMF::HTML_CONTENT] = html_;
93 return { utdId, udsObject };
94 }
95
InitPixelMapEntry()96 PasteDataEntry PasteDataEntryTest::InitPixelMapEntry()
97 {
98 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP);
99 auto udsObject = std::make_shared<Object>();
100 udsObject->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
101 uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
102 InitializationOptions opts = {
103 {5, 7},
104 PixelFormat::ARGB_8888, PixelFormat::ARGB_8888
105 };
106 std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
107 std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
108 udsObject->value_[UDMF::PIXEL_MAP] = pixelMapIn;
109 return { utdId, udsObject };
110 }
111
CheckPlainUds(const std::shared_ptr<PasteDataEntry> entry)112 void PasteDataEntryTest::CheckPlainUds(const std::shared_ptr<PasteDataEntry> entry)
113 {
114 ASSERT_NE(entry, nullptr);
115 ASSERT_EQ(MIMETYPE_TEXT_PLAIN, entry->GetMimeType());
116 auto decodeValue = entry->GetValue();
117 auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
118 ASSERT_NE(object, nullptr);
119 auto objectValue = (*object)->value_;
120 auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
121 ASSERT_NE(typeValue, nullptr);
122 ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT));
123 auto value = std::get_if<std::string>(&objectValue[UDMF::CONTENT]);
124 ASSERT_NE(value, nullptr);
125 ASSERT_EQ(*value, text_);
126 }
127
CheckPixelMapUds(const std::shared_ptr<PasteDataEntry> entry)128 void PasteDataEntryTest::CheckPixelMapUds(const std::shared_ptr<PasteDataEntry> entry)
129 {
130 ASSERT_NE(entry, nullptr);
131 ASSERT_EQ(MIMETYPE_PIXELMAP, entry->GetMimeType());
132 auto decodeValue = entry->GetValue();
133 auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
134 ASSERT_NE(object, nullptr);
135 auto objectValue = (*object)->value_;
136 auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
137 ASSERT_NE(typeValue, nullptr);
138 ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP));
139 auto value = std::get_if<std::shared_ptr<PixelMap>>(&objectValue[UDMF::PIXEL_MAP]);
140 ASSERT_NE(value, nullptr);
141 ImageInfo imageInfo = {};
142 (*value)->GetImageInfo(imageInfo);
143 ASSERT_TRUE(imageInfo.size.height == 7);
144 ASSERT_TRUE(imageInfo.size.width == 5);
145 ASSERT_TRUE(imageInfo.pixelFormat == PixelFormat::ARGB_8888);
146 }
147
148 /**
149 * @tc.name: Convert001
150 * @tc.desc: convert to palinText;
151 * @tc.type: FUNC
152 * @tc.require:entries
153 * @tc.author: tarowang
154 */
155 HWTEST_F(PasteDataEntryTest, Convert001, TestSize.Level0)
156 {
157 auto entry = InitPlainTextEntry();
158 auto str = entry.ConvertToPlainText();
159 ASSERT_NE(nullptr, str);
160 EXPECT_EQ(text_, *str);
161
162 entry = InitHtmlEntry();
163 auto html = entry.ConvertToHtml();
164 ASSERT_NE(nullptr, html);
165 EXPECT_EQ(html_, *html);
166
167 entry = InitUriEntry();
168 auto uri = entry.ConvertToUri();
169 ASSERT_NE(nullptr, uri);
170 EXPECT_EQ(uri_, uri->ToString());
171
172 entry = InitWantEntry();
173 auto want = entry.ConvertToWant();
174 ASSERT_NE(nullptr, want);
175 int32_t idValue1 = want->GetIntParam("id", 0);
176 ASSERT_EQ(idValue1, 123);
177
178 entry = InitPixelMapEntry();
179 auto pixelMap = entry.ConvertToPixelMap();
180 ASSERT_NE(nullptr, pixelMap);
181 ImageInfo imageInfo = {};
182 pixelMap->GetImageInfo(imageInfo);
183 ASSERT_TRUE(imageInfo.size.height == height_);
184 ASSERT_TRUE(imageInfo.size.width == width_);
185 ASSERT_TRUE(imageInfo.pixelFormat == PixelFormat::ARGB_8888);
186 }
187
188 /**
189 * @tc.name: Convert002
190 * @tc.desc: convert to html;
191 * @tc.type: FUNC
192 * @tc.require:entries
193 * @tc.author: tarowang
194 */
195 HWTEST_F(PasteDataEntryTest, Convert002, TestSize.Level0)
196 {
197 PasteDataEntry entry;
198 std::string utdId = "NotHTML";
199 entry.SetUtdId(utdId);
200 auto html = entry.ConvertToHtml();
201 EXPECT_EQ(html, nullptr);
202
203 utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML);
204 entry.SetUtdId(utdId);
205 std::string value_str = "TestString";
206 entry.SetValue(value_str);
207 html = entry.ConvertToHtml();
208 EXPECT_EQ(*html, "TestString");
209
210 int32_t value_int = 123;
211 entry.SetValue(value_int);
212 html = entry.ConvertToHtml();
213 EXPECT_EQ(html, nullptr);
214 }
215
216 /**
217 * @tc.name: Convert003
218 * @tc.desc: convert to uri;
219 * @tc.type: FUNC
220 * @tc.require:entries
221 * @tc.author: tarowang
222 */
223 HWTEST_F(PasteDataEntryTest, Convert003, TestSize.Level0)
224 {
225 PasteDataEntry entry;
226 std::string utdId = "NotURI";
227 entry.SetUtdId(utdId);
228 auto uri = entry.ConvertToUri();
229 EXPECT_EQ(uri, nullptr);
230
231 utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI);
232 entry.SetUtdId(utdId);
233 std::string value_str = "TestString";
234 entry.SetValue(value_str);
235 auto value = entry.GetValue();
236 auto res = std::get<std::string>(value);
237 uri = entry.ConvertToUri();
238 EXPECT_EQ(*uri, Uri(res));
239 }
240
241 /**
242 * @tc.name: Convert004
243 * @tc.desc: convert to want;
244 * @tc.type: FUNC
245 * @tc.require:entries
246 * @tc.author: tarowang
247 */
248 HWTEST_F(PasteDataEntryTest, Convert004, TestSize.Level0)
249 {
250 PasteDataEntry entry;
251 std::string utdId = "NotWANT";
252 entry.SetUtdId(utdId);
253 auto want = entry.ConvertToWant();
254 EXPECT_EQ(want, nullptr);
255
256 utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::OPENHARMONY_WANT);
257 entry.SetUtdId(utdId);
258 std::string value_str = "TestString";
259 entry.SetValue(value_str);
260 want = entry.ConvertToWant();
261 EXPECT_EQ(want, nullptr);
262 }
263
264 /**
265 * @tc.name: Convert005
266 * @tc.desc: convert to PixelMap;
267 * @tc.type: FUNC
268 * @tc.require:entries
269 * @tc.author: tarowang
270 */
271 HWTEST_F(PasteDataEntryTest, Convert005, TestSize.Level0)
272 {
273 PasteDataEntry entry;
274 std::string utdId = "NotPixelMap";
275 entry.SetUtdId(utdId);
276 auto pixelMap = entry.ConvertToPixelMap();
277 EXPECT_EQ(pixelMap, nullptr);
278
279 utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP);
280 entry.SetUtdId(utdId);
281 auto pixelmap_ = std::make_shared<Media::PixelMap>();
282 entry.SetValue(pixelmap_);
283 pixelMap = entry.ConvertToPixelMap();
284 EXPECT_EQ(pixelMap, pixelmap_);
285
286 std::string value_str = "TestString";
287 entry.SetValue(value_str);
288 pixelMap = entry.ConvertToPixelMap();
289 EXPECT_EQ(pixelMap, nullptr);
290
291 auto object = std::make_shared<Object>();
292 object->value_[UDMF::HTML_CONTENT] = html_;
293 entry.SetValue(object);
294 pixelMap = entry.ConvertToPixelMap();
295 EXPECT_EQ(pixelMap, nullptr);
296
297 object->value_[UDMF::UNIFORM_DATA_TYPE] = html_;
298 entry.SetValue(object);
299 pixelMap = entry.ConvertToPixelMap();
300 EXPECT_EQ(pixelMap, nullptr);
301
302 object->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
303 entry.SetValue(object);
304 pixelMap = entry.ConvertToPixelMap();
305 EXPECT_EQ(pixelMap, nullptr);
306 }
307
308 /**
309 * @tc.name: Convert006
310 * @tc.desc: convert to CustomData;
311 * @tc.type: FUNC
312 * @tc.require:entries
313 * @tc.author: tarowang
314 */
315 HWTEST_F(PasteDataEntryTest, Convert006, TestSize.Level0)
316 {
317 PasteDataEntry entry;
318 std::string value_str = "TestString";
319 entry.SetValue(value_str);
320 auto customData = entry.ConvertToCustomData();
321 EXPECT_EQ(customData, nullptr);
322
323 auto object = std::make_shared<Object>();
324 object->value_[UDMF::HTML_CONTENT] = html_;
325 entry.SetValue(object);
326 customData = entry.ConvertToCustomData();
327 EXPECT_EQ(customData, nullptr);
328
329 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
330 object->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
331 entry.SetValue(object);
332 customData = entry.ConvertToCustomData();
333 EXPECT_EQ(customData, nullptr);
334 }
335
336 /**
337 * @tc.name: EntriesTest001
338 * @tc.desc:
339 * @tc.type: FUNC
340 * @tc.require:
341 * @tc.author:tarowang
342 */
343 HWTEST_F(PasteDataEntryTest, EntryTlvTest001, TestSize.Level0)
344 {
345 PasteDataEntry entry;
346 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
347 entry.SetUtdId(utdId);
348 entry.SetMimeType(MIMETYPE_TEXT_PLAIN);
349 entry.SetValue(text_);
350
351 std::vector<std::uint8_t> buffer;
352 entry.Encode(buffer);
353 PasteDataEntry decodePasteEntry;
354 auto ret = decodePasteEntry.Decode(buffer);
355
356 ASSERT_EQ(ret, true);
357 ASSERT_EQ(decodePasteEntry.GetUtdId(), utdId);
358 ASSERT_EQ(decodePasteEntry.GetMimeType(), MIMETYPE_TEXT_PLAIN);
359 auto value = decodePasteEntry.GetValue();
360 auto str = std::get_if<std::string>(&value);
361 ASSERT_NE(str, nullptr);
362 ASSERT_EQ(text_, *str);
363 }
364
365 /**
366 * @tc.name: EntryTlvTest002
367 * @tc.desc:
368 * @tc.type: FUNC
369 * @tc.require:
370 * @tc.author:tarowang
371 */
372 HWTEST_F(PasteDataEntryTest, EntryTlvTest002, TestSize.Level0)
373 {
374 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
375 auto entry = InitPlainTextEntry();
376 std::vector<std::uint8_t> buffer;
377 entry.Encode(buffer);
378 PasteDataEntry decodePasteEntry;
379 auto ret = decodePasteEntry.Decode(buffer);
380 ASSERT_EQ(ret, true);
381 ASSERT_EQ(decodePasteEntry.GetUtdId(), utdId);
382 ASSERT_EQ(decodePasteEntry.GetMimeType(), MIMETYPE_TEXT_PLAIN);
383 CheckPlainUds(std::make_shared<PasteDataEntry>(decodePasteEntry));
384 }
385
386 /**
387 * @tc.name: EntryTlvTest003
388 * @tc.desc:
389 * @tc.type: EntryTlvTest003 with pixelMap
390 * @tc.require:
391 * @tc.author:tarowang
392 */
393 HWTEST_F(PasteDataEntryTest, EntryTlvTest003, TestSize.Level0)
394 {
395 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP);
396 auto entry = InitPixelMapEntry();
397 std::vector<std::uint8_t> buffer;
398 entry.Encode(buffer);
399 PasteDataEntry decodePasteEntry;
400 auto ret = decodePasteEntry.Decode(buffer);
401 ASSERT_EQ(ret, true);
402 ASSERT_EQ(decodePasteEntry.GetUtdId(), utdId);
403 ASSERT_EQ(decodePasteEntry.GetMimeType(), MIMETYPE_PIXELMAP);
404 CheckPixelMapUds(std::make_shared<PasteDataEntry>(decodePasteEntry));
405 }
406
407 /**
408 * @tc.name: EntryTest001
409 * @tc.desc: Whether to include the target content
410 * @tc.type: FUNC
411 * @tc.require: entries
412 * @tc.author:tarowang
413 */
414 HWTEST_F(PasteDataEntryTest, EntryTest001, TestSize.Level0)
415 {
416 PasteDataEntry entry;
417 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
418 EXPECT_EQ(entry.HasContent(utdId), false);
419
420 utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK);
421 EXPECT_EQ(entry.HasContent(utdId), false);
422
423 utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML);
424 EXPECT_EQ(entry.HasContent(utdId), false);
425
426 utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI);
427 EXPECT_EQ(entry.HasContent(utdId), false);
428
429 utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP);
430 EXPECT_EQ(entry.HasContent(utdId), false);
431
432 utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::OPENHARMONY_WANT);
433 EXPECT_EQ(entry.HasContent(utdId), false);
434
435 utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::ENTITY);
436 EXPECT_EQ(entry.HasContent(utdId), false);
437 }
438
439 /**
440 * @tc.name: EntryTest002
441 * @tc.desc: convert to string
442 * @tc.type: FUNC
443 * @tc.require:entries
444 * @tc.author:tarowang
445 */
446 HWTEST_F(PasteDataEntryTest, EntryTest002, TestSize.Level0)
447 {
448 CommonUtils utils;
449 UDType uDType = UDType::PLAIN_TEXT;
450 std::string expect = MIMETYPE_TEXT_PLAIN;
451 EXPECT_EQ(utils.Convert(uDType), expect);
452
453 uDType = UDType::HYPERLINK;
454 EXPECT_EQ(utils.Convert(uDType), expect);
455
456 uDType = UDType::HTML;
457 expect = MIMETYPE_TEXT_HTML;
458 EXPECT_EQ(utils.Convert(uDType), expect);
459
460 uDType = UDType::FILE;
461 expect = MIMETYPE_TEXT_URI;
462 EXPECT_EQ(utils.Convert(uDType), expect);
463
464 uDType = UDType::IMAGE;
465 EXPECT_EQ(utils.Convert(uDType), expect);
466
467 uDType = UDType::VIDEO;
468 EXPECT_EQ(utils.Convert(uDType), expect);
469
470 uDType = UDType::AUDIO;
471 EXPECT_EQ(utils.Convert(uDType), expect);
472
473 uDType = UDType::FOLDER;
474 EXPECT_EQ(utils.Convert(uDType), expect);
475
476 uDType = UDType::FILE_URI;
477 EXPECT_EQ(utils.Convert(uDType), expect);
478
479 uDType = UDType::SYSTEM_DEFINED_PIXEL_MAP;
480 expect = MIMETYPE_PIXELMAP;
481 EXPECT_EQ(utils.Convert(uDType), expect);
482
483 uDType = UDType::OPENHARMONY_WANT;
484 expect = MIMETYPE_TEXT_WANT;
485 EXPECT_EQ(utils.Convert(uDType), expect);
486
487 uDType = UDType::ENTITY;
488 EXPECT_EQ(utils.Convert(uDType), "general.entity");
489 }
490
491 /**
492 * @tc.name: EntryTest003
493 * @tc.desc: convert to UDType
494 * @tc.type: FUNC
495 * @tc.require:entries
496 * @tc.author:tarowang
497 */
498 HWTEST_F(PasteDataEntryTest, EntryTest003, TestSize.Level0)
499 {
500 CommonUtils utils;
501 int32_t uDType = 1;
502 std::string mimeType = MIMETYPE_TEXT_URI;
503 EXPECT_EQ(utils.Convert(uDType, mimeType), UDMF::OBJECT);
504
505 uDType = UDMF::UD_BUTT;
506 EXPECT_EQ(utils.Convert(uDType, mimeType), UDMF::FILE_URI);
507
508 mimeType = MIMETYPE_TEXT_PLAIN;
509 EXPECT_EQ(utils.Convert(uDType, mimeType), UDMF::PLAIN_TEXT);
510
511 mimeType = MIMETYPE_TEXT_HTML;
512 EXPECT_EQ(utils.Convert(uDType, mimeType), UDMF::HTML);
513
514 mimeType = MIMETYPE_TEXT_WANT;
515 EXPECT_EQ(utils.Convert(uDType, mimeType), UDMF::OPENHARMONY_WANT);
516
517 mimeType = MIMETYPE_PIXELMAP;
518 EXPECT_EQ(utils.Convert(uDType, mimeType), UDMF::SYSTEM_DEFINED_PIXEL_MAP);
519
520 mimeType = "general.entity";
521 EXPECT_EQ(utils.Convert(uDType, mimeType), UDMF::ENTITY);
522
523 mimeType = "test";
524 EXPECT_EQ(utils.Convert(uDType, mimeType), UDMF::APPLICATION_DEFINED_RECORD);
525 }
526 } // namespace OHOS::MiscServices