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 #define LOG_TAG "UnifiedMetaTest"
16
17 #include <unistd.h>
18 #include <gtest/gtest.h>
19 #include <string>
20
21 #include "logger.h"
22 #include "udmf_capi_common.h"
23 #include "unified_meta.h"
24
25 using namespace testing::ext;
26 using namespace OHOS::UDMF;
27 using namespace OHOS;
28 namespace OHOS::Test {
29 using namespace std;
30
31 class UnifiedMetaTest : public testing::Test {
32 public:
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp() override;
36 void TearDown() override;
37 static constexpr int INT32_SIZE = 4;
38 static constexpr int INT64_SIZE = 8;
39 static constexpr int BOOL_SIZE = 1;
40 static constexpr int DOUBLE_SIZE = 8;
41 };
42
SetUpTestCase()43 void UnifiedMetaTest::SetUpTestCase()
44 {
45 }
46
TearDownTestCase()47 void UnifiedMetaTest::TearDownTestCase()
48 {
49 }
50
SetUp()51 void UnifiedMetaTest::SetUp()
52 {
53 }
54
TearDown()55 void UnifiedMetaTest::TearDown()
56 {
57 }
58
59 /**
60 * @tc.name: IsValidType001
61 * @tc.desc: Normal testcase of IsValidType
62 * @tc.type: FUNC
63 */
64 HWTEST_F(UnifiedMetaTest, IsValidType001, TestSize.Level1)
65 {
66 LOG_INFO(UDMF_TEST, "IsValidType001 begin.");
67 int32_t value = 0;
68 bool ret = UnifiedDataUtils::IsValidType(value);
69 EXPECT_EQ(ret, value >= ENTITY && value < UD_BUTT);
70 LOG_INFO(UDMF_TEST, "IsValidType001 end.");
71 }
72
73 /**
74 * @tc.name: GetEnumNum001
75 * @tc.desc: Normal testcase of GetEnumNum
76 * @tc.type: FUNC
77 */
78 HWTEST_F(UnifiedMetaTest, GetEnumNum001, TestSize.Level1)
79 {
80 LOG_INFO(UDMF_TEST, "GetEnumNum001 begin.");
81 const std::string shareOption = "";
82 int32_t ret = ShareOptionsUtil::GetEnumNum(shareOption);
83 EXPECT_EQ(ret, ShareOptions::SHARE_OPTIONS_BUTT);
84 LOG_INFO(UDMF_TEST, "GetEnumNum001 end.");
85 }
86
87 /**
88 * @tc.name: GetEnumNum002
89 * @tc.desc: Abnormal testcase of GetEnumNum, shareOption is APP_SHARE_OPTIONS.enumNum
90 * @tc.type: FUNC
91 */
92 HWTEST_F(UnifiedMetaTest, GetEnumNum002, TestSize.Level1)
93 {
94 LOG_INFO(UDMF_TEST, "GetEnumNum002 begin.");
95 const std::string shareOption = "CROSS_APP";
96 int32_t ret = ShareOptionsUtil::GetEnumNum(shareOption);
97 EXPECT_EQ(ret, 1);
98 LOG_INFO(UDMF_TEST, "GetEnumNum002 end.");
99 }
100
101 /**
102 * @tc.name: GetEnumStr001
103 * @tc.desc: Normal testcase of GetEnumStr
104 * @tc.type: FUNC
105 */
106 HWTEST_F(UnifiedMetaTest, GetEnumStr001, TestSize.Level1)
107 {
108 LOG_INFO(UDMF_TEST, "GetEnumStr001 begin.");
109 int32_t shareOption = 4;
110 std::string ret = ShareOptionsUtil::GetEnumStr(shareOption);
111 EXPECT_EQ(ret, "");
112 LOG_INFO(UDMF_TEST, "GetEnumStr001 end.");
113 }
114
115 /**
116 * @tc.name: GetEnumStr002
117 * @tc.desc: Abnormal testcase of GetEnumStr, shareOption is APP_SHARE_OPTIONS.enumStr
118 * @tc.type: FUNC
119 */
120 HWTEST_F(UnifiedMetaTest, GetEnumStr002, TestSize.Level1)
121 {
122 LOG_INFO(UDMF_TEST, "GetEnumStr002 begin.");
123 int32_t shareOption = 1;
124 std::string ret = ShareOptionsUtil::GetEnumStr(shareOption);
125 EXPECT_NE(ret, "");
126 LOG_INFO(UDMF_TEST, "GetEnumStr002 end.");
127 }
128
129 /**
130 * @tc.name: IsValidUtdId001
131 * @tc.desc: Normal testcase of IsValidUtdId
132 * @tc.type: FUNC
133 */
134 HWTEST_F(UnifiedMetaTest, IsValidUtdId001, TestSize.Level1)
135 {
136 std::string utdId = "general.text";
137 bool ret = UtdUtils::IsValidUtdId(utdId);
138 EXPECT_TRUE(ret);
139 }
140
141 /**
142 * @tc.name: IsValidUtdId002
143 * @tc.desc: Abnormal testcase of IsValidUtdId
144 * @tc.type: FUNC
145 */
146 HWTEST_F(UnifiedMetaTest, IsValidUtdId002, TestSize.Level1)
147 {
148 std::string utdId = "general.ptp";
149 bool ret = UtdUtils::IsValidUtdId(utdId);
150 EXPECT_FALSE(ret);
151 }
152
153 /**
154 * @tc.name: GetUtdEnumFromUtdId001
155 * @tc.desc: Normal testcase of GetUtdEnumFromUtdId
156 * @tc.type: FUNC
157 */
158 HWTEST_F(UnifiedMetaTest, GetUtdEnumFromUtdId001, TestSize.Level1)
159 {
160 std::string utdId = "general.text";
161 int32_t ret = UtdUtils::GetUtdEnumFromUtdId(utdId);
162 EXPECT_EQ(ret, UDType::TEXT);
163 }
164
165 /**
166 * @tc.name: GetUtdEnumFromUtdId002
167 * @tc.desc: Abnormal testcase of GetUtdEnumFromUtdId
168 * @tc.type: FUNC
169 */
170 HWTEST_F(UnifiedMetaTest, GetUtdEnumFromUtdId002, TestSize.Level1)
171 {
172 std::string utdId = "general.ptp";
173 int32_t ret = UtdUtils::GetUtdEnumFromUtdId(utdId);
174 EXPECT_EQ(ret, UDType::UD_BUTT);
175 }
176
177 /**
178 * @tc.name: GetUtdIdFromUtdEnum001
179 * @tc.desc: Normal testcase of GetUtdIdFromUtdEnum
180 * @tc.type: FUNC
181 */
182 HWTEST_F(UnifiedMetaTest, GetUtdIdFromUtdEnum001, TestSize.Level1)
183 {
184 std::string ret = UtdUtils::GetUtdIdFromUtdEnum(UDType::TEXT);
185 EXPECT_EQ(ret, "general.text");
186 }
187
188 /**
189 * @tc.name: GetUtdIdFromUtdEnum002
190 * @tc.desc: Abnormal testcase of GetUtdIdFromUtdEnum
191 * @tc.type: FUNC
192 */
193 HWTEST_F(UnifiedMetaTest, GetUtdIdFromUtdEnum002, TestSize.Level1)
194 {
195 std::string ret = UtdUtils::GetUtdIdFromUtdEnum(UDType::UD_BUTT);
196 EXPECT_TRUE(ret.empty());
197
198 std::string ret1 = UtdUtils::GetUtdIdFromUtdEnum(UDType::UD_BUTT + 1);
199 EXPECT_TRUE(ret1.empty());
200 }
201
202 /**
203 * @tc.name: GetUtdTypes001
204 * @tc.desc: Normal testcase of GetUtdTypes
205 * @tc.type: FUNC
206 */
207 HWTEST_F(UnifiedMetaTest, GetUtdTypes001, TestSize.Level1)
208 {
209 std::vector<UtdType> ret = UtdUtils::GetUtdTypes();
210 EXPECT_TRUE(ret.size() > 0);
211 }
212
213 /**
214 * @tc.name: UnifiedDataUtilsIsValidType001
215 * @tc.desc: Abnormal testcase of IsValidType
216 * @tc.type: FUNC
217 */
218 HWTEST_F(UnifiedMetaTest, UnifiedDataUtilsIsValidType001, TestSize.Level1)
219 {
220 bool ret = UnifiedDataUtils::IsValidType(UDType::UD_BUTT);
221 EXPECT_FALSE(ret);
222
223 bool ret1 = UnifiedDataUtils::IsValidType(UDType::ENTITY - 1);
224 EXPECT_FALSE(ret1);
225
226 bool ret2 = UnifiedDataUtils::IsValidType(UDType::UD_BUTT + 1);
227 EXPECT_FALSE(ret2);
228 }
229
230 /**
231 * @tc.name: UnifiedDataUtilsIsValidType002
232 * @tc.desc: Normal testcase of IsValidType
233 * @tc.type: FUNC
234 */
235 HWTEST_F(UnifiedMetaTest, UnifiedDataUtilsIsValidType002, TestSize.Level1)
236 {
237 bool ret = UnifiedDataUtils::IsValidType(UDType::TEXT);
238 EXPECT_TRUE(ret);
239
240 bool ret1 = UnifiedDataUtils::IsValidType(UDType::ENTITY);
241 EXPECT_TRUE(ret1);
242 }
243
244 /**
245 * @tc.name: IsValidIntention001
246 * @tc.desc: Normal testcase of IsValidIntention
247 * @tc.type: FUNC
248 */
249 HWTEST_F(UnifiedMetaTest, IsValidIntention001, TestSize.Level1)
250 {
251 bool ret = UnifiedDataUtils::IsValidIntention(Intention::UD_INTENTION_DRAG);
252 EXPECT_TRUE(ret);
253
254 bool ret1 = UnifiedDataUtils::IsValidIntention(Intention::UD_INTENTION_DATA_HUB);
255 EXPECT_TRUE(ret1);
256
257 bool ret2 = UnifiedDataUtils::IsValidIntention(Intention::UD_INTENTION_SYSTEM_SHARE);
258 EXPECT_TRUE(ret2);
259
260 bool ret3 = UnifiedDataUtils::IsValidIntention(Intention::UD_INTENTION_PICKER);
261 EXPECT_TRUE(ret3);
262
263 bool ret4 = UnifiedDataUtils::IsValidIntention(Intention::UD_INTENTION_MENU);
264 EXPECT_TRUE(ret4);
265 }
266
267 /**
268 * @tc.name: IsValidIntention002
269 * @tc.desc: Abnormal testcase of IsValidIntention
270 * @tc.type: FUNC
271 */
272 HWTEST_F(UnifiedMetaTest, IsValidIntention002, TestSize.Level1)
273 {
274 bool ret = UnifiedDataUtils::IsValidIntention(Intention::UD_INTENTION_BASE);
275 EXPECT_FALSE(ret);
276
277 bool ret1 = UnifiedDataUtils::IsValidIntention(Intention::UD_INTENTION_BUTT);
278 EXPECT_FALSE(ret1);
279
280 bool ret2 = UnifiedDataUtils::IsValidIntention(Intention::UD_INTENTION_BASE - 1);
281 EXPECT_FALSE(ret2);
282
283 bool ret3 = UnifiedDataUtils::IsValidIntention(Intention::UD_INTENTION_BUTT + 1);
284 EXPECT_FALSE(ret3);
285 }
286
287 /**
288 * @tc.name: ShareOptionsUtilIsValid001
289 * @tc.desc: Normal testcase of IsValid
290 * @tc.type: FUNC
291 */
292 HWTEST_F(UnifiedMetaTest, ShareOptionsUtilIsValid001, TestSize.Level1)
293 {
294 bool ret = ShareOptionsUtil::IsValid(ShareOptions::IN_APP);
295 EXPECT_TRUE(ret);
296
297 bool ret1 = ShareOptionsUtil::IsValid(ShareOptions::CROSS_APP);
298 EXPECT_TRUE(ret1);
299 }
300
301 /**
302 * @tc.name: ShareOptionsUtilIsValid002
303 * @tc.desc: Abnormal testcase of IsValid
304 * @tc.type: FUNC
305 */
306 HWTEST_F(UnifiedMetaTest, ShareOptionsUtilIsValid002, TestSize.Level1)
307 {
308 bool ret = ShareOptionsUtil::IsValid(ShareOptions::IN_APP - 1);
309 EXPECT_FALSE(ret);
310
311 bool ret1 = ShareOptionsUtil::IsValid(ShareOptions::SHARE_OPTIONS_BUTT);
312 EXPECT_FALSE(ret1);
313
314 bool ret2 = ShareOptionsUtil::IsValid(ShareOptions::SHARE_OPTIONS_BUTT + 1);
315 EXPECT_FALSE(ret2);
316 }
317
318 /**
319 * @tc.name: GetVariantSize001
320 * @tc.desc: Normal testcase of GetVariantSize
321 * @tc.type: FUNC
322 */
323 HWTEST_F(UnifiedMetaTest, GetVariantSize001, TestSize.Level1)
324 {
325 UDVariant variant;
326 // case int32_t
327 variant = (int32_t)100;
328 size_t int32tSize = UnifiedDataUtils::GetVariantSize(variant);
329 EXPECT_EQ(int32tSize, INT32_SIZE);
330
331 variant = (int64_t)100;
332 size_t int64tSize = UnifiedDataUtils::GetVariantSize(variant);
333 EXPECT_EQ(int64tSize, INT64_SIZE);
334
335 variant = true;
336 size_t boolSize = UnifiedDataUtils::GetVariantSize(variant);
337 EXPECT_EQ(boolSize, BOOL_SIZE);
338
339 variant = 100.0001;
340 size_t doubleSize = UnifiedDataUtils::GetVariantSize(variant);
341 EXPECT_EQ(doubleSize, DOUBLE_SIZE);
342
343 std::string str = "string size";
344 variant = str;
345 size_t strSize = UnifiedDataUtils::GetVariantSize(variant);
346 EXPECT_EQ(strSize, str.size());
347
348 std::vector<uint8_t> uVecEmpty;
349 variant = uVecEmpty;
350 size_t vecEmpSize = UnifiedDataUtils::GetVariantSize(variant);
351 EXPECT_EQ(vecEmpSize, uVecEmpty.size());
352
353 std::vector<uint8_t> uVec(100, 100);
354 variant = uVec;
355 size_t uVecSize = UnifiedDataUtils::GetVariantSize(variant);
356 EXPECT_EQ(uVecSize, uVec.size());
357 }
358
359 /**
360 * @tc.name: GetDetailsSize001
361 * @tc.desc: Normal testcase of GetDetailsSize
362 * @tc.type: FUNC
363 */
364 HWTEST_F(UnifiedMetaTest, GetDetailsSize001, TestSize.Level1)
365 {
366 std::string int32Key = "int32Key";
367 std::string int64Key = "int64Key";
368 std::string strKey = "strKey";
369 std::string str = "string size";
370 UDDetails details = {
371 {int32Key, (int32_t)100},
372 {int64Key, (int64_t)100},
373 {strKey, str}
374 };
375 size_t ret = UnifiedDataUtils::GetDetailsSize(details);
376 EXPECT_EQ(ret, int32Key.size() + int64Key.size() + strKey.size() + INT32_SIZE + INT64_SIZE + str.size());
377 }
378
379 /**
380 * @tc.name: IsPersistByIntention001
381 * @tc.desc: Normal testcase of IsPersist
382 * @tc.type: FUNC
383 */
384 HWTEST_F(UnifiedMetaTest, IsPersistByIntention001, TestSize.Level1)
385 {
386 bool ret = UnifiedDataUtils::IsPersist(Intention::UD_INTENTION_DATA_HUB);
387 EXPECT_TRUE(ret);
388
389 bool ret1 = UnifiedDataUtils::IsPersist(Intention::UD_INTENTION_BUTT);
390 EXPECT_FALSE(ret1);
391
392 bool ret2 = UnifiedDataUtils::IsPersist(Intention::UD_INTENTION_DRAG);
393 EXPECT_FALSE(ret2);
394
395 bool ret3 = UnifiedDataUtils::IsPersist(Intention::UD_INTENTION_BASE);
396 EXPECT_FALSE(ret3);
397
398 bool ret4 = UnifiedDataUtils::IsPersist(Intention::UD_INTENTION_PICKER);
399 EXPECT_TRUE(ret4);
400
401 bool ret5 = UnifiedDataUtils::IsPersist(Intention::UD_INTENTION_MENU);
402 EXPECT_TRUE(ret5);
403
404 bool ret6 = UnifiedDataUtils::IsPersist(Intention::UD_INTENTION_SYSTEM_SHARE);
405 EXPECT_TRUE(ret6);
406 }
407
408 /**
409 * @tc.name: IsPersistByStr001
410 * @tc.desc: Normal testcase of IsPersist
411 * @tc.type: FUNC
412 */
413 HWTEST_F(UnifiedMetaTest, IsPersistByStr001, TestSize.Level1)
414 {
415 bool ret = UnifiedDataUtils::IsPersist("DataHub");
416 EXPECT_TRUE(ret);
417
418 bool ret1 = UnifiedDataUtils::IsPersist("drag");
419 EXPECT_FALSE(ret1);
420
421 bool ret2 = UnifiedDataUtils::IsPersist("invalid param");
422 EXPECT_FALSE(ret2);
423
424 bool ret3 = UnifiedDataUtils::IsPersist("Picker");
425 EXPECT_TRUE(ret3);
426
427 bool ret4 = UnifiedDataUtils::IsPersist("Menu");
428 EXPECT_TRUE(ret4);
429
430 bool ret5 = UnifiedDataUtils::IsPersist("SystemShare");
431 EXPECT_TRUE(ret5);
432 }
433
434 /**
435 * @tc.name: GetIntentionByString001
436 * @tc.desc: Normal testcase of IsPersist
437 * @tc.type: FUNC
438 */
439 HWTEST_F(UnifiedMetaTest, GetIntentionByString001, TestSize.Level1)
440 {
441 Intention ret = UnifiedDataUtils::GetIntentionByString("DataHub");
442 EXPECT_EQ(ret, Intention::UD_INTENTION_DATA_HUB);
443
444 Intention ret1 = UnifiedDataUtils::GetIntentionByString("drag");
445 EXPECT_EQ(ret1, Intention::UD_INTENTION_DRAG);
446
447 Intention ret2 = UnifiedDataUtils::GetIntentionByString("invalid param");
448 EXPECT_EQ(ret2, UD_INTENTION_BUTT);
449
450 Intention ret3 = UnifiedDataUtils::GetIntentionByString("Picker");
451 EXPECT_EQ(ret3, Intention::UD_INTENTION_PICKER);
452
453 Intention ret4 = UnifiedDataUtils::GetIntentionByString("Menu");
454 EXPECT_EQ(ret4, Intention::UD_INTENTION_MENU);
455
456 Intention ret5 = UnifiedDataUtils::GetIntentionByString("SystemShare");
457 EXPECT_EQ(ret5, Intention::UD_INTENTION_SYSTEM_SHARE);
458 }
459
460 /**
461 * @tc.name: IsValidOptionsNonDrag001
462 * @tc.desc: Normal testcase of IsPersist
463 * @tc.type: FUNC
464 */
465 HWTEST_F(UnifiedMetaTest, IsValidOptionsNonDrag001, TestSize.Level1)
466 {
467 std::string keyDataHub = "udmf://DataHub/com.hmos.photos/CSl;cdcGFcmdkasaccCSCAAScscdc";
468 std::string keyDrag = "udmf://drag/com.hmos.photos/CSl;cdcGFcmdkasaccCSCAAScscdc";
469 std::string keyPicker = "udmf://Picker/com.hmos.photos/CSl;cdcGFcmdkasaccCSCAAScscdc";
470 std::string keyMenu = "udmf://Menu/com.hmos.photos/CSl;cdcGFcmdkasaccCSCAAScscdc";
471 std::string keySystemShare = "udmf://SystemShare/com.hmos.photos/CSl;cdcGFcmdkasaccCSCAAScscdc";
472 std::string intentionDataHub = "DataHub";
473 std::string intentionDrag = "drag";
474 std::string intentionPicker = "Picker";
475 std::string intentionMenu = "Menu";
476 std::string intentionSystemShare = "SystemShare";
477 std::string intentionEmpty = "";
478 UnifiedKey key1("");
479
480 bool ret = UnifiedDataUtils::IsValidOptionsNonDrag(key1, intentionDataHub);
481 EXPECT_TRUE(ret);
482
483 UnifiedKey key2(keyDataHub);
484 bool ret1 = UnifiedDataUtils::IsValidOptionsNonDrag(key2, intentionEmpty);
485 EXPECT_TRUE(ret1);
486 bool ret2 = UnifiedDataUtils::IsValidOptionsNonDrag(key2, intentionDataHub);
487 EXPECT_TRUE(ret2);
488 bool ret3 = UnifiedDataUtils::IsValidOptionsNonDrag(key2, intentionDrag);
489 EXPECT_FALSE(ret3);
490 bool ret4 = UnifiedDataUtils::IsValidOptionsNonDrag(key2, intentionPicker);
491 EXPECT_FALSE(ret4);
492 bool ret5 = UnifiedDataUtils::IsValidOptionsNonDrag(key2, intentionMenu);
493 EXPECT_FALSE(ret5);
494 bool ret6 = UnifiedDataUtils::IsValidOptionsNonDrag(key2, intentionSystemShare);
495 EXPECT_FALSE(ret6);
496 UnifiedKey key3(keyDrag);
497 bool ret7 = UnifiedDataUtils::IsValidOptionsNonDrag(key3, intentionDrag);
498 EXPECT_FALSE(ret7);
499 UnifiedKey key4(keyPicker);
500 bool ret8 = UnifiedDataUtils::IsValidOptionsNonDrag(key4, intentionPicker);
501 EXPECT_TRUE(ret8);
502 UnifiedKey key5(keyMenu);
503 bool ret9 = UnifiedDataUtils::IsValidOptionsNonDrag(key5, intentionMenu);
504 EXPECT_TRUE(ret9);
505 UnifiedKey key6(keySystemShare);
506 bool ret10 = UnifiedDataUtils::IsValidOptionsNonDrag(key6, intentionSystemShare);
507 EXPECT_TRUE(ret10);
508 }
509
510 /**
511 * @tc.name: IsValidOptionsNonDrag
512 * @tc.desc: Normal testcase of key and intention
513 * @tc.type: FUNC
514 */
515 HWTEST_F(UnifiedMetaTest, IsAllowedQuery, TestSize.Level1)
516 {
517 std::string keyDataHub = "udmf://DataHub/com.hmos.photos/CSl;cdcGFcmdkasaccCSCAAScscdc";
518 std::string keyDrag = "udmf://drag/com.hmos.photos/CSl;cdcGFcmdkasaccCSCAAScscdc";
519 std::string keyPicker = "udmf://Picker/com.hmos.photos/CSl;cdcGFcmdkasaccCSCAAScscdc";
520 std::string keyMenu = "udmf://Menu/com.hmos.photos/CSl;cdcGFcmdkasaccCSCAAScscdc";
521 std::string keySystemShare = "udmf://SystemShare/com.hmos.photos/CSl;cdcGFcmdkasaccCSCAAScscdc";
522 std::string intentionDataHub = "DataHub";
523 std::string intentionDrag = "drag";
524 std::string intentionPicker = "Picker";
525 std::string intentionMenu = "Menu";
526 std::string intentionSystemShare = "SystemShare";
527 std::string intentionEmpty = "";
528 UnifiedKey key1("");
529
530 bool ret = UnifiedDataUtils::IsValidOptionsNonDrag(key1, intentionDataHub);
531 EXPECT_TRUE(ret);
532 bool ret1 = UnifiedDataUtils::IsValidOptionsNonDrag(key1, intentionPicker);
533 EXPECT_FALSE(ret1);
534 UnifiedKey key2(keyDataHub);
535 bool ret2 = UnifiedDataUtils::IsValidOptionsNonDrag(key2, intentionEmpty);
536 EXPECT_TRUE(ret2);
537 bool ret3 = UnifiedDataUtils::IsValidOptionsNonDrag(key2, intentionDataHub);
538 EXPECT_TRUE(ret3);
539 bool ret4 = UnifiedDataUtils::IsValidOptionsNonDrag(key2, intentionDrag);
540 EXPECT_FALSE(ret4);
541 bool ret5 = UnifiedDataUtils::IsValidOptionsNonDrag(key2, intentionPicker);
542 EXPECT_FALSE(ret5);
543 bool ret6 = UnifiedDataUtils::IsValidOptionsNonDrag(key2, intentionMenu);
544 EXPECT_FALSE(ret6);
545 bool ret7 = UnifiedDataUtils::IsValidOptionsNonDrag(key2, intentionSystemShare);
546 EXPECT_FALSE(ret7);
547 UnifiedKey key3(keyDrag);
548 bool ret8 = UnifiedDataUtils::IsValidOptionsNonDrag(key3, intentionDrag);
549 EXPECT_FALSE(ret8);
550 }
551
552 /**
553 * @tc.name: IsValidQuery001
554 * @tc.desc: Normal testcase of key and intention
555 * @tc.type: FUNC
556 */
557 HWTEST_F(UnifiedMetaTest, IsValidQuery001, TestSize.Level1)
558 {
559 std::string keyPicker = "udmf://Picker/com.hmos.photos/CSl;cdcGFcmdkasaccCSCAAScscdc";
560 std::string intentionDataHub = "DataHub";
561 std::string intentionDrag = "drag";
562 std::string intentionPicker = "Picker";
563 std::string intentionMenu = "Menu";
564 std::string intentionSystemShare = "SystemShare";
565 std::string intentionEmpty = "";
566
567 UnifiedKey key(keyPicker);
568 bool ret = UnifiedDataUtils::IsValidOptionsNonDrag(key, intentionPicker);
569 EXPECT_TRUE(ret);
570
571 bool ret1 = UnifiedDataUtils::IsValidOptionsNonDrag(key, intentionEmpty);
572 EXPECT_TRUE(ret1);
573
574 bool ret2 = UnifiedDataUtils::IsValidOptionsNonDrag(key, intentionDataHub);
575 EXPECT_FALSE(ret2);
576
577 bool ret3 = UnifiedDataUtils::IsValidOptionsNonDrag(key, intentionDrag);
578 EXPECT_FALSE(ret3);
579
580 bool ret4 = UnifiedDataUtils::IsValidOptionsNonDrag(key, intentionMenu);
581 EXPECT_FALSE(ret4);
582
583 bool ret5 = UnifiedDataUtils::IsValidOptionsNonDrag(key, intentionSystemShare);
584 EXPECT_FALSE(ret5);
585 }
586
587 /**
588 * @tc.name: IsValidOptions002
589 * @tc.desc: Abnormal testcase of IsValidOptions, intention is empty
590 * @tc.type: FUNC
591 */
592 HWTEST_F(UnifiedMetaTest, IsValidOptions002, TestSize.Level1)
593 {
594 UnifiedKey key;
595 key.key = "key://";
596 std::string intention;
597 std::string validIntention;
598 UnifiedDataUtils unifiedDataUtils;
599 bool ret = unifiedDataUtils.IsValidOptions(key, intention, validIntention);
600 EXPECT_FALSE(ret);
601 }
602
603 /**
604 * @tc.name: IsValidOptions003
605 * @tc.desc: Abnormal testcase of IsValidOptions, intention != validIntention
606 * @tc.type: FUNC
607 */
608 HWTEST_F(UnifiedMetaTest, IsValidOptions003, TestSize.Level1)
609 {
610 UnifiedKey key;
611 key.key = "key://";
612 std::string intention = "drag";
613 std::string validIntention = "DataHub";
614 UnifiedDataUtils unifiedDataUtils;
615 bool ret = unifiedDataUtils.IsValidOptions(key, intention, validIntention);
616 EXPECT_FALSE(ret);
617 }
618
619 /**
620 * @tc.name: IsValidOptions004
621 * @tc.desc: Abnormal testcase of IsValidOptions, key.intention != validIntention
622 * @tc.type: FUNC
623 */
624 HWTEST_F(UnifiedMetaTest, IsValidOptions004, TestSize.Level1)
625 {
626 UnifiedKey key;
627 key.key = "key://";
628 key.intention = "DataHub";
629 std::string intention = "DataHub";
630 std::string validIntention = "drag";
631 UnifiedDataUtils unifiedDataUtils;
632 bool ret = unifiedDataUtils.IsValidOptions(key, intention, validIntention);
633 EXPECT_FALSE(ret);
634 }
635
636 /**
637 * @tc.name: ConvertToUDDetails001
638 * @tc.desc: Abnormal testcase of ConvertToUDDetails, object is nullptr
639 * @tc.type: FUNC
640 */
641 HWTEST_F(UnifiedMetaTest, ConvertToUDDetails001, TestSize.Level1)
642 {
643 std::shared_ptr<Object> object = nullptr;
644 EXPECT_NO_FATAL_FAILURE(ObjectUtils::ConvertToUDDetails(object));
645 }
646
647 /**
648 * @tc.name: GetValueSize001
649 * @tc.desc: Normal testcase of GetValueSize
650 * @tc.type: FUNC
651 */
652 HWTEST_F(UnifiedMetaTest, GetValueSize001, TestSize.Level1)
653 {
654 ValueType value = std::make_shared<OHOS::Media::PixelMap>();
655 bool isCalValueType = true;
656 int64_t ret = ObjectUtils::GetValueSize(value, isCalValueType);
657 EXPECT_EQ(ret, (std::get<std::shared_ptr<OHOS::Media::PixelMap>>(value))->GetByteCount());
658 }
659
660 /**
661 * @tc.name: GetValueSize002
662 * @tc.desc: Normal testcase of GetValueSize
663 * @tc.type: FUNC
664 */
665 HWTEST_F(UnifiedMetaTest, GetValueSize002, TestSize.Level1)
666 {
667 ValueType value = std::make_shared<OHOS::AAFwk::Want>();
668 bool isCalValueType = true;
669 int64_t ret = ObjectUtils::GetValueSize(value, isCalValueType);
670 EXPECT_NE(ret, 0);
671 }
672
673 /**
674 * @tc.name: GetValueSize003
675 * @tc.desc: Abnormal testcase of GetValueSize, value is invalid
676 * @tc.type: FUNC
677 */
678 HWTEST_F(UnifiedMetaTest, GetValueSize003, TestSize.Level1)
679 {
680 ValueType value = true;
681 bool isCalValueType = true;
682 int64_t ret = ObjectUtils::GetValueSize(value, isCalValueType);
__anonb7f662cb0102(const auto &val) 683 EXPECT_EQ(ret, std::visit([] (const auto &val) { return sizeof(val); }, value));
684 }
685
686 /* *
687 * @tc.name: GetObjectValueSize_001
688 * @tc.desc: Abnormal test of GetObjectValueSize, key is DETAILS
689 * @tc.type: FUNC
690 */
691 HWTEST_F(UnifiedMetaTest, GetObjectValueSize_001, TestSize.Level1)
692 {
693 std::shared_ptr<Object> object = std::make_shared<Object>();
694 bool isCalValueType = true;
695 object->value_["details"] = std::make_shared<OHOS::Media::PixelMap>();
696 size_t ret = ObjectUtils::GetObjectValueSize(object, isCalValueType);
697 EXPECT_EQ(ret, 0);
698 }
699
700 /* *
701 * @tc.name: GetAllObjectSize_001
702 * @tc.desc: Abnormal test of GetAllObjectSize, object is nullptr
703 * @tc.type: FUNC
704 */
705 HWTEST_F(UnifiedMetaTest, GetAllObjectSize_001, TestSize.Level1)
706 {
707 std::shared_ptr<Object> object = nullptr;
708 int64_t ret = ObjectUtils::GetAllObjectSize(object);
709 EXPECT_EQ(ret, 0);
710 }
711
712 /**
713 * @tc.name: GetValue001
714 * @tc.desc: Normal testcase of IsPersist
715 * @tc.type: FUNC
716 */
717 HWTEST_F(UnifiedMetaTest, GetValue001, TestSize.Level1)
718 {
719 Object object;
720 std::string key = "key";
721 std::string content = "content";
722 object.value_ = {
723 {key, content}
724 };
725 std::string value;
726 bool ret = object.GetValue(key, value);
727 EXPECT_TRUE(ret);
728 EXPECT_EQ(value, content);
729
730 std::string valueEmpty;
731 bool ret1 = object.GetValue("invalid key", valueEmpty);
732 EXPECT_FALSE(ret1);
733 EXPECT_TRUE(valueEmpty.empty());
734 }
735
736 /**
737 * @tc.name: GetValue002
738 * @tc.desc: Normal testcase of IsPersist
739 * @tc.type: FUNC
740 */
741 HWTEST_F(UnifiedMetaTest, GetValue002, TestSize.Level1)
742 {
743 Object object;
744 std::shared_ptr<Object> objectInner = std::make_shared<Object>();
745 std::string key = "key";
746 std::string keyObj = "keyObj";
747 std::string content = "content";
748 objectInner->value_ = {
749 {key, content}
750 };
751 object.value_ = {
752 {key, content},
753 {keyObj, objectInner}
754 };
755 std::shared_ptr<Object> value = std::make_shared<Object>();
756 bool ret = object.GetValue(keyObj, value);
757 EXPECT_TRUE(ret);
758
759 std::string innerValue;
760 bool ret1 = value->GetValue(key, innerValue);
761 EXPECT_TRUE(ret1);
762 EXPECT_EQ(innerValue, content);
763
764 std::shared_ptr<Object> valueEmpty = std::make_shared<Object>();
765 bool ret2 = object.GetValue("invalid key", valueEmpty);
766 EXPECT_FALSE(ret2);
767 }
768
769 /**
770 * @tc.name: IsFileMangerIntention
771 * @tc.desc: IsFileMangerIntention testcase
772 * @tc.type: FUNC
773 */
774 HWTEST_F(UnifiedMetaTest, IsFileMangerIntention, TestSize.Level1)
775 {
776 std::string intentionDataHub = "DataHub";
777 std::string intentionDrag = "drag";
778 std::string intentionPicker = "Picker";
779 std::string intentionMenu = "Menu";
780 std::string intentionSystemShare = "SystemShare";
781
782 bool ret = UnifiedDataUtils::IsFileMangerIntention(intentionDataHub);
783 EXPECT_FALSE(ret);
784 bool ret1 = UnifiedDataUtils::IsFileMangerIntention(intentionDrag);
785 EXPECT_FALSE(ret1);
786 bool ret2 = UnifiedDataUtils::IsFileMangerIntention(intentionPicker);
787 EXPECT_TRUE(ret2);
788 bool ret3 = UnifiedDataUtils::IsFileMangerIntention(intentionMenu);
789 EXPECT_TRUE(ret3);
790 bool ret4 = UnifiedDataUtils::IsFileMangerIntention(intentionSystemShare);
791 EXPECT_TRUE(ret4);
792 }
793
794 /**
795 * @tc.name: IsFileMangerIntention
796 * @tc.desc: IsFileMangerIntention testcase
797 * @tc.type: FUNC
798 */
799 HWTEST_F(UnifiedMetaTest, GetBelongsToFileType, TestSize.Level1)
800 {
801 std::string utdId = "";
802 std::string fileType = UnifiedDataUtils::GetBelongsToFileType(utdId);
803 EXPECT_TRUE(fileType.empty());
804
805 utdId = "general.html";
806 fileType = UnifiedDataUtils::GetBelongsToFileType(utdId);
807 EXPECT_TRUE(fileType.empty());
808
809 utdId = "general.plain-text";
810 fileType = UnifiedDataUtils::GetBelongsToFileType(utdId);
811 EXPECT_TRUE(fileType.empty());
812
813 utdId = "general.text";
814 fileType = UnifiedDataUtils::GetBelongsToFileType(utdId);
815 EXPECT_TRUE(fileType.empty());
816
817 utdId = "aaccss";
818 fileType = UnifiedDataUtils::GetBelongsToFileType(utdId);
819 EXPECT_TRUE(fileType.empty());
820
821 utdId = "general.file";
822 fileType = UnifiedDataUtils::GetBelongsToFileType(utdId);
823 EXPECT_EQ(fileType, "general.file");
824
825 utdId = "general.image";
826 fileType = UnifiedDataUtils::GetBelongsToFileType(utdId);
827 EXPECT_EQ(fileType, "general.image");
828
829 utdId = "general.avi";
830 fileType = UnifiedDataUtils::GetBelongsToFileType(utdId);
831 EXPECT_EQ(fileType, "general.video");
832
833 utdId = "com.adobe.pdf";
834 fileType = UnifiedDataUtils::GetBelongsToFileType(utdId);
835 EXPECT_EQ(fileType, "general.file");
836 }
837 } // OHOS::Test