1 /*
2 * Copyright (c) 2023 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 "UdmfClientTest"
16 #include <gtest/gtest.h>
17
18 #include <unistd.h>
19 #include <thread>
20 #include <chrono>
21
22 #include "token_setproc.h"
23 #include "accesstoken_kit.h"
24 #include "directory_ex.h"
25 #include "nativetoken_kit.h"
26
27 #include "logger.h"
28 #include "udmf_client.h"
29 #include "application_defined_record.h"
30 #include "audio.h"
31 #include "file.h"
32 #include "file_uri.h"
33 #include "folder.h"
34 #include "html.h"
35 #include "image.h"
36 #include "link.h"
37 #include "plain_text.h"
38 #include "system_defined_appitem.h"
39 #include "system_defined_form.h"
40 #include "system_defined_pixelmap.h"
41 #include "system_defined_record.h"
42 #include "text.h"
43 #include "unified_data_helper.h"
44 #include "unified_html_record_process.h"
45 #include "video.h"
46
47 using namespace testing::ext;
48 using namespace OHOS::Security::AccessToken;
49 using namespace OHOS::UDMF;
50 using namespace OHOS;
51 namespace OHOS::Test {
52 constexpr int SLEEP_TIME = 50; // 50 ms
53 constexpr int BATCH_SIZE_2K = 2000;
54 constexpr int BATCH_SIZE_5K = 5000;
55 constexpr double BASE_CONVERSION = 1000.0;
56 constexpr const char *FILE_SCHEME_PREFIX = "file://";
57 class UdmfClientTest : public testing::Test {
58 public:
59 static void SetUpTestCase();
60 static void TearDownTestCase();
61 void SetUp() override;
62 void TearDown() override;
63
64 void SetNativeToken(const std::string &processName);
65 static void AllocHapToken1();
66 static void AllocHapToken2();
67 void SetHapToken1();
68 void SetHapToken2();
69
70 void AddPrivilege(QueryOption &option);
71 void AddPrivilege1(QueryOption &option);
72 void CompareDetails(const UDDetails &details);
73 void GetEmptyData(QueryOption &option);
74 void GetFileUriUnifiedData(UnifiedData &data);
75 void ComparePixelMap(const UDDetails details, std::shared_ptr<OHOS::Media::PixelMap> pixelMapIn);
76
77 static constexpr int USER_ID = 100;
78 static constexpr int INST_INDEX = 0;
79 };
80
SetUpTestCase()81 void UdmfClientTest::SetUpTestCase()
82 {
83 AllocHapToken1();
84 AllocHapToken2();
85 }
86
TearDownTestCase()87 void UdmfClientTest::TearDownTestCase()
88 {
89 auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo1", INST_INDEX);
90 AccessTokenKit::DeleteToken(tokenId);
91 tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo2", INST_INDEX);
92 AccessTokenKit::DeleteToken(tokenId);
93 }
94
SetUp()95 void UdmfClientTest::SetUp()
96 {
97 SetHapToken1();
98 }
99
TearDown()100 void UdmfClientTest::TearDown()
101 {
102 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
103 std::vector<UnifiedData> unifiedDataSet;
104 UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
105 query = { .intention = Intention::UD_INTENTION_DRAG };
106 UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
107 }
108
SetNativeToken(const std::string & processName)109 void UdmfClientTest::SetNativeToken(const std::string &processName)
110 {
111 auto tokenId = AccessTokenKit::GetNativeTokenId(processName);
112 SetSelfTokenID(tokenId);
113 }
114
AllocHapToken1()115 void UdmfClientTest::AllocHapToken1()
116 {
117 HapInfoParams info = {
118 .userID = USER_ID,
119 .bundleName = "ohos.test.demo1",
120 .instIndex = INST_INDEX,
121 .appIDDesc = "ohos.test.demo1"
122 };
123
124 HapPolicyParams policy = {
125 .apl = APL_NORMAL,
126 .domain = "test.domain",
127 .permList = {
128 {
129 .permissionName = "ohos.permission.test",
130 .bundleName = "ohos.test.demo1",
131 .grantMode = 1,
132 .availableLevel = APL_NORMAL,
133 .label = "label",
134 .labelId = 1,
135 .description = "test1",
136 .descriptionId = 1
137 }
138 },
139 .permStateList = {
140 {
141 .permissionName = "ohos.permission.test",
142 .isGeneral = true,
143 .resDeviceID = { "local" },
144 .grantStatus = { PermissionState::PERMISSION_GRANTED },
145 .grantFlags = { 1 }
146 }
147 }
148 };
149 auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
150 SetSelfTokenID(tokenID.tokenIDEx);
151 }
152
AllocHapToken2()153 void UdmfClientTest::AllocHapToken2()
154 {
155 HapInfoParams info = {
156 .userID = USER_ID,
157 .bundleName = "ohos.test.demo2",
158 .instIndex = INST_INDEX,
159 .appIDDesc = "ohos.test.demo2"
160 };
161
162 HapPolicyParams policy = {
163 .apl = APL_NORMAL,
164 .domain = "test.domain",
165 .permList = {
166 {
167 .permissionName = "ohos.permission.test",
168 .bundleName = "ohos.test.demo2",
169 .grantMode = 1,
170 .availableLevel = APL_NORMAL,
171 .label = "label",
172 .labelId = 1,
173 .description = "test2",
174 .descriptionId = 1
175 }
176 },
177 .permStateList = {
178 {
179 .permissionName = "ohos.permission.test",
180 .isGeneral = true,
181 .resDeviceID = { "local" },
182 .grantStatus = { PermissionState::PERMISSION_GRANTED },
183 .grantFlags = { 1 }
184 }
185 }
186 };
187 auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
188 SetSelfTokenID(tokenID.tokenIDEx);
189 }
190
SetHapToken1()191 void UdmfClientTest::SetHapToken1()
192 {
193 auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo1", INST_INDEX);
194 SetSelfTokenID(tokenId);
195 }
196
SetHapToken2()197 void UdmfClientTest::SetHapToken2()
198 {
199 auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo2", INST_INDEX);
200 SetSelfTokenID(tokenId);
201 }
202
AddPrivilege(QueryOption & option)203 void UdmfClientTest::AddPrivilege(QueryOption &option)
204 {
205 Privilege privilege;
206 privilege.tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo2", INST_INDEX);
207 privilege.readPermission = "readPermission";
208 privilege.writePermission = "writePermission";
209 SetNativeToken("msdp_sa");
210 auto status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
211 ASSERT_EQ(status, E_OK);
212 }
213
AddPrivilege1(QueryOption & option)214 void UdmfClientTest::AddPrivilege1(QueryOption &option)
215 {
216 Privilege privilege;
217 privilege.tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo1", INST_INDEX);
218 privilege.readPermission = "readPermission";
219 privilege.writePermission = "writePermission";
220 SetNativeToken("msdp_sa");
221 auto status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
222 ASSERT_EQ(status, E_OK);
223 }
224
CompareDetails(const UDDetails & details)225 void UdmfClientTest::CompareDetails(const UDDetails &details)
226 {
227 for (const auto &detail : details) {
228 auto key = detail.first;
229 EXPECT_EQ(key, "udmf_key");
230 auto value = detail.second;
231 auto str = std::get<std::string>(value);
232 EXPECT_EQ(str, "udmf_value");
233 }
234 }
235
ComparePixelMap(const UDDetails details,std::shared_ptr<OHOS::Media::PixelMap> pixelMapIn)236 void UdmfClientTest::ComparePixelMap(const UDDetails details, std::shared_ptr<OHOS::Media::PixelMap> pixelMapIn)
237 {
238 auto width = details.find("width");
239 if (width != details.end()) {
240 EXPECT_EQ(std::get<int32_t>(width->second), pixelMapIn->GetWidth());
241 }
242 auto height = details.find("height");
243 if (height != details.end()) {
244 EXPECT_EQ(std::get<int32_t>(height->second), pixelMapIn->GetHeight());
245 }
246 auto pixel_format = details.find("pixel-format");
247 if (pixel_format != details.end()) {
248 EXPECT_EQ(std::get<int32_t>(pixel_format->second), static_cast<int32_t>(pixelMapIn->GetPixelFormat()));
249 }
250 auto alpha_type = details.find("alpha-type");
251 if (alpha_type != details.end()) {
252 EXPECT_EQ(std::get<int32_t>(alpha_type->second), static_cast<int32_t>(pixelMapIn->GetAlphaType()));
253 }
254 auto udmf_key = details.find("udmf_key");
255 if (udmf_key != details.end()) {
256 EXPECT_EQ(std::get<std::string>(udmf_key->second), "udmf_value");
257 }
258 }
259
GetEmptyData(QueryOption & option)260 void UdmfClientTest::GetEmptyData(QueryOption &option)
261 {
262 UnifiedData data;
263 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
264 auto status = UdmfClient::GetInstance().GetData(option, data);
265 EXPECT_EQ(status, E_NOT_FOUND);
266 }
267
GetFileUriUnifiedData(UnifiedData & data)268 void UdmfClientTest::GetFileUriUnifiedData(UnifiedData &data)
269 {
270 std::shared_ptr<Object> obj = std::make_shared<Object>();
271 obj->value_[UNIFORM_DATA_TYPE] = "general.file-uri";
272 obj->value_[FILE_URI_PARAM] = "http://demo.com";
273 obj->value_[FILE_TYPE] = "abcdefg";
274 auto record = std::make_shared<UnifiedRecord>(FILE_URI, obj);
275
276 std::shared_ptr<Object> obj1 = std::make_shared<Object>();
277 obj1->value_[UNIFORM_DATA_TYPE] = "general.file-uri";
278 obj1->value_[FILE_URI_PARAM] = "http://demo.com";
279 obj1->value_[FILE_TYPE] = "general.image";
280 auto record1 = std::make_shared<UnifiedRecord>(FILE_URI, obj1);
281
282 std::shared_ptr<Object> obj2 = std::make_shared<Object>();
283 obj2->value_[UNIFORM_DATA_TYPE] = "general.file-uri";
284 obj2->value_[FILE_URI_PARAM] = "http://demo.com";
285 obj2->value_[FILE_TYPE] = "general.audio";
286 auto record2 = std::make_shared<UnifiedRecord>(FILE_URI, obj2);
287 data.AddRecord(record);
288 data.AddRecord(record1);
289 data.AddRecord(record2);
290 }
291
292 /**
293 * @tc.name: SetData001
294 * @tc.desc: Set data with invalid params
295 * @tc.type: FUNC
296 */
297 HWTEST_F(UdmfClientTest, SetData001, TestSize.Level1)
298 {
299 LOG_INFO(UDMF_TEST, "SetData001 begin.");
300
301 CustomOption option = { .intention = Intention::UD_INTENTION_DRAG };
302 UnifiedData data;
303 std::string key;
304 auto status = UdmfClient::GetInstance().SetData(option, data, key);
305 EXPECT_EQ(status, E_INVALID_PARAMETERS);
306
307 option = { .intention = Intention::UD_INTENTION_BUTT };
308 auto text = std::make_shared<Text>();
309 UDDetails details;
310 details.insert({ "udmf_key", "udmf_value" });
311 text->SetDetails(details);
312 data.AddRecord(text);
313 status = UdmfClient::GetInstance().SetData(option, data, key);
314 EXPECT_EQ(status, E_INVALID_PARAMETERS);
315
316 option = {};
317 status = UdmfClient::GetInstance().SetData(option, data, key);
318 EXPECT_EQ(status, E_INVALID_PARAMETERS);
319
320 option = { .intention = Intention::UD_INTENTION_BASE };
321 status = UdmfClient::GetInstance().SetData(option, data, key);
322 EXPECT_EQ(status, E_INVALID_PARAMETERS);
323 LOG_INFO(UDMF_TEST, "SetData001 end.");
324 }
325
326 /**
327 * @tc.name: SetData002
328 * @tc.desc: Set Text record with valid params and get data
329 * @tc.type: FUNC
330 */
331 HWTEST_F(UdmfClientTest, SetData002, TestSize.Level1)
332 {
333 LOG_INFO(UDMF_TEST, "SetData002 begin.");
334
335 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
336 UnifiedData data1;
337 auto text1 = std::make_shared<Text>();
338 UDDetails details1;
339 details1.insert({ "udmf_key", "udmf_value" });
340 text1->SetDetails(details1);
341 data1.AddRecord(text1);
342 std::string key;
343 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
344 ASSERT_EQ(status, E_OK);
345
346 QueryOption option2 = { .key = key };
347 AddPrivilege(option2);
348 SetHapToken2();
349 UnifiedData data2;
350 status = UdmfClient::GetInstance().GetData(option2, data2);
351 ASSERT_EQ(status, E_OK);
352
353 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
354 ASSERT_NE(record2, nullptr);
355 auto type = record2->GetType();
356 EXPECT_EQ(type, UDType::TEXT);
357
358 auto text2 = static_cast<Text *>(record2.get());
359 ASSERT_NE(text2, nullptr);
360 CompareDetails(text2->GetDetails());
361
362 GetEmptyData(option2);
363
364 LOG_INFO(UDMF_TEST, "SetData002 end.");
365 }
366
367 /**
368 * @tc.name: SetData003
369 * @tc.desc: Set PlainText record with valid params and get data
370 * @tc.type: FUNC
371 */
372 HWTEST_F(UdmfClientTest, SetData003, TestSize.Level1)
373 {
374 LOG_INFO(UDMF_TEST, "SetData003 begin.");
375
376 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
377 UnifiedData data1;
378 auto plainText1 = std::make_shared<PlainText>();
379 UDDetails details1;
380 details1.insert({ "udmf_key", "udmf_value" });
381 plainText1->SetDetails(details1);
382 plainText1->SetContent("content");
383 plainText1->SetAbstract("abstract");
384 data1.AddRecord(plainText1);
385 std::string key;
386 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
387 ASSERT_EQ(status, E_OK);
388
389 QueryOption option2 = { .key = key };
390 AddPrivilege(option2);
391 SetHapToken2();
392 UnifiedData data2;
393 status = UdmfClient::GetInstance().GetData(option2, data2);
394 ASSERT_EQ(status, E_OK);
395
396 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
397 ASSERT_NE(record2, nullptr);
398 auto type = record2->GetType();
399 ASSERT_EQ(type, UDType::PLAIN_TEXT);
400
401 auto text2 = static_cast<Text *>(record2.get());
402 ASSERT_NE(text2, nullptr);
403 CompareDetails(text2->GetDetails());
404
405 auto plainText2 = static_cast<PlainText *>(record2.get());
406 ASSERT_NE(plainText2, nullptr);
407 EXPECT_EQ(plainText1->GetContent(), plainText2->GetContent());
408 EXPECT_EQ(plainText1->GetAbstract(), plainText2->GetAbstract());
409
410 GetEmptyData(option2);
411
412 LOG_INFO(UDMF_TEST, "SetData003 end.");
413 }
414
415 /**
416 * @tc.name: SetData004
417 * @tc.desc: Set Html record with valid params and get data
418 * @tc.type: FUNC
419 */
420 HWTEST_F(UdmfClientTest, SetData004, TestSize.Level1)
421 {
422 LOG_INFO(UDMF_TEST, "SetData004 begin.");
423
424 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
425 UnifiedData data1;
426 std::string key;
427 auto html1 = std::make_shared<Html>();
428 UDDetails details1;
429 details1.insert({ "udmf_key", "udmf_value" });
430 html1->SetDetails(details1);
431 html1->SetHtmlContent("htmlcontent");
432 html1->SetPlainContent("plainContent");
433 data1.AddRecord(html1);
434 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
435 ASSERT_EQ(status, E_OK);
436
437 QueryOption option2 = { .key = key };
438 AddPrivilege(option2);
439 SetHapToken2();
440 UnifiedData data2;
441 status = UdmfClient::GetInstance().GetData(option2, data2);
442 ASSERT_EQ(status, E_OK);
443
444 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
445 ASSERT_NE(record2, nullptr);
446 auto type = record2->GetType();
447 ASSERT_EQ(type, UDType::HTML);
448
449 auto text2 = static_cast<Text *>(record2.get());
450 ASSERT_NE(text2, nullptr);
451 CompareDetails(text2->GetDetails());
452
453 auto html2 = static_cast<Html *>(record2.get());
454 ASSERT_NE(html2, nullptr);
455 EXPECT_EQ(html1->GetHtmlContent(), html2->GetHtmlContent());
456 EXPECT_EQ(html1->GetPlainContent(), html2->GetPlainContent());
457
458 GetEmptyData(option2);
459
460 LOG_INFO(UDMF_TEST, "SetData004 end.");
461 }
462
463 /**
464 * @tc.name: SetData005
465 * @tc.desc: Set Link record with valid params and get data
466 * @tc.type: FUNC
467 */
468 HWTEST_F(UdmfClientTest, SetData005, TestSize.Level1)
469 {
470 LOG_INFO(UDMF_TEST, "SetData005 begin.");
471
472 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
473 UnifiedData data1;
474 std::string key;
475 auto link1 = std::make_shared<Link>();
476 UDDetails details1;
477 details1.insert({ "udmf_key", "udmf_value" });
478 link1->SetDetails(details1);
479 link1->SetUrl("url");
480 link1->SetDescription("description");
481 data1.AddRecord(link1);
482 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
483 ASSERT_EQ(status, E_OK);
484
485 QueryOption option2 = { .key = key };
486 AddPrivilege(option2);
487 SetHapToken2();
488 UnifiedData data2;
489 status = UdmfClient::GetInstance().GetData(option2, data2);
490 ASSERT_EQ(status, E_OK);
491
492 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
493 ASSERT_NE(record2, nullptr);
494 auto type = record2->GetType();
495 ASSERT_EQ(type, UDType::HYPERLINK);
496
497 auto text2 = static_cast<Text *>(record2.get());
498 ASSERT_NE(text2, nullptr);
499 CompareDetails(text2->GetDetails());
500
501 auto link2 = static_cast<Link *>(record2.get());
502 ASSERT_NE(link2, nullptr);
503 EXPECT_EQ(link1->GetUrl(), link2->GetUrl());
504 EXPECT_EQ(link1->GetDescription(), link2->GetDescription());
505
506 GetEmptyData(option2);
507
508 LOG_INFO(UDMF_TEST, "SetData005 end.");
509 }
510
511 /**
512 * @tc.name: SetData006
513 * @tc.desc: Set File record with valid params and get data
514 * @tc.type: FUNC
515 */
516 HWTEST_F(UdmfClientTest, SetData006, TestSize.Level1)
517 {
518 LOG_INFO(UDMF_TEST, "SetData006 begin.");
519
520 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
521 UnifiedData data1;
522 std::string key;
523 auto file1 = std::make_shared<File>();
524 file1->SetRemoteUri("remoteUri");
525 UDDetails details1;
526 details1.insert({ "udmf_key", "udmf_value" });
527 file1->SetDetails(details1);
528 data1.AddRecord(file1);
529 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
530 ASSERT_EQ(status, E_OK);
531
532 QueryOption option2 = { .key = key };
533 AddPrivilege(option2);
534 SetHapToken2();
535 UnifiedData data2;
536 status = UdmfClient::GetInstance().GetData(option2, data2);
537 ASSERT_EQ(status, E_OK);
538
539 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
540 ASSERT_NE(record2, nullptr);
541 auto type = record2->GetType();
542 ASSERT_EQ(type, UDType::FILE);
543
544 auto file2 = static_cast<File *>(record2.get());
545 ASSERT_NE(file2, nullptr);
546 EXPECT_EQ(file1->GetRemoteUri(), file2->GetRemoteUri());
547 CompareDetails(file2->GetDetails());
548
549 GetEmptyData(option2);
550
551 LOG_INFO(UDMF_TEST, "SetData006 end.");
552 }
553
554 /**
555 * @tc.name: SetData007
556 * @tc.desc: Set Image record with valid params and get data
557 * @tc.type: FUNC
558 */
559 HWTEST_F(UdmfClientTest, SetData007, TestSize.Level1)
560 {
561 LOG_INFO(UDMF_TEST, "SetData007 begin.");
562
563 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
564 UnifiedData data1;
565 std::string key;
566 auto image1 = std::make_shared<Image>();
567 UDDetails details1;
568 details1.insert({ "udmf_key", "udmf_value" });
569 image1->SetDetails(details1);
570 image1->SetRemoteUri("remoteUri");
571 data1.AddRecord(image1);
572 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
573 ASSERT_EQ(status, E_OK);
574
575 QueryOption option2 = { .key = key };
576 AddPrivilege(option2);
577 SetHapToken2();
578 UnifiedData data2;
579 status = UdmfClient::GetInstance().GetData(option2, data2);
580 ASSERT_EQ(status, E_OK);
581
582 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
583 ASSERT_NE(record2, nullptr);
584 auto type = record2->GetType();
585 ASSERT_EQ(type, UDType::IMAGE);
586
587 auto file2 = static_cast<File *>(record2.get());
588 ASSERT_NE(file2, nullptr);
589 CompareDetails(file2->GetDetails());
590
591 auto image2 = static_cast<Image *>(record2.get());
592 ASSERT_NE(image2, nullptr);
593 EXPECT_EQ(image1->GetRemoteUri(), image2->GetRemoteUri());
594
595 GetEmptyData(option2);
596
597 LOG_INFO(UDMF_TEST, "SetData007 end.");
598 }
599
600 /**
601 * @tc.name: SetData008
602 * @tc.desc: Set Video record with valid params and get data
603 * @tc.type: FUNC
604 */
605 HWTEST_F(UdmfClientTest, SetData008, TestSize.Level1)
606 {
607 LOG_INFO(UDMF_TEST, "SetData008 begin.");
608
609 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
610 UnifiedData data1;
611 std::string key;
612 auto video1 = std::make_shared<Video>();
613 UDDetails details1;
614 details1.insert({ "udmf_key", "udmf_value" });
615 video1->SetDetails(details1);
616 video1->SetRemoteUri("remoteUri");
617 data1.AddRecord(video1);
618 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
619 ASSERT_EQ(status, E_OK);
620
621 QueryOption option2 = { .key = key };
622 AddPrivilege(option2);
623 SetHapToken2();
624 UnifiedData data2;
625 status = UdmfClient::GetInstance().GetData(option2, data2);
626 ASSERT_EQ(status, E_OK);
627
628 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
629 ASSERT_NE(record2, nullptr);
630 auto type = record2->GetType();
631 EXPECT_EQ(type, UDType::VIDEO);
632
633 auto file2 = static_cast<File *>(record2.get());
634 ASSERT_NE(file2, nullptr);
635 CompareDetails(file2->GetDetails());
636
637 auto video2 = static_cast<Video *>(record2.get());
638 ASSERT_NE(video2, nullptr);
639 EXPECT_EQ(video1->GetRemoteUri(), video2->GetRemoteUri());
640
641 GetEmptyData(option2);
642
643 LOG_INFO(UDMF_TEST, "SetData008 end.");
644 }
645
646 /**
647 * @tc.name: SetData009
648 * @tc.desc: Set Audio record with valid params and get data
649 * @tc.type: FUNC
650 */
651 HWTEST_F(UdmfClientTest, SetData009, TestSize.Level1)
652 {
653 LOG_INFO(UDMF_TEST, "SetData009 begin.");
654
655 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
656 UnifiedData data1;
657 std::string key;
658 auto audio1 = std::make_shared<Audio>();
659 UDDetails details1;
660 details1.insert({ "udmf_key", "udmf_value" });
661 audio1->SetDetails(details1);
662 audio1->SetRemoteUri("remoteUri");
663 data1.AddRecord(audio1);
664 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
665 ASSERT_EQ(status, E_OK);
666
667 QueryOption option2 = { .key = key };
668 AddPrivilege(option2);
669 SetHapToken2();
670 UnifiedData data2;
671 status = UdmfClient::GetInstance().GetData(option2, data2);
672 ASSERT_EQ(status, E_OK);
673
674 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
675 ASSERT_NE(record2, nullptr);
676 auto type = record2->GetType();
677 EXPECT_EQ(type, UDType::AUDIO);
678
679 auto file2 = static_cast<File *>(record2.get());
680 ASSERT_NE(file2, nullptr);
681 CompareDetails(file2->GetDetails());
682
683 auto audio2 = static_cast<Audio *>(record2.get());
684 ASSERT_NE(audio2, nullptr);
685 EXPECT_EQ(audio1->GetRemoteUri(), audio2->GetRemoteUri());
686
687 GetEmptyData(option2);
688
689 LOG_INFO(UDMF_TEST, "SetData009 end.");
690 }
691
692 /**
693 * @tc.name: SetData010
694 * @tc.desc: Set Folder record with valid params and get data
695 * @tc.type: FUNC
696 */
697 HWTEST_F(UdmfClientTest, SetData010, TestSize.Level1)
698 {
699 LOG_INFO(UDMF_TEST, "SetData010 begin.");
700
701 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
702 UnifiedData data1;
703 std::string key;
704 auto folder1 = std::make_shared<Folder>();
705 UDDetails details1;
706 details1.insert({ "udmf_key", "udmf_value" });
707 folder1->SetDetails(details1);
708 folder1->SetRemoteUri("remoteUri");
709 data1.AddRecord(folder1);
710 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
711 ASSERT_EQ(status, E_OK);
712
713 QueryOption option2 = { .key = key };
714 AddPrivilege(option2);
715 SetHapToken2();
716 UnifiedData data2;
717 status = UdmfClient::GetInstance().GetData(option2, data2);
718 ASSERT_EQ(status, E_OK);
719
720 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
721 ASSERT_NE(record2, nullptr);
722 auto type = record2->GetType();
723 EXPECT_EQ(type, UDType::FOLDER);
724
725 auto file2 = static_cast<File *>(record2.get());
726 ASSERT_NE(file2, nullptr);
727 CompareDetails(file2->GetDetails());
728
729 auto folder2 = static_cast<Folder *>(record2.get());
730 ASSERT_NE(folder2, nullptr);
731 EXPECT_EQ(folder1->GetRemoteUri(), folder2->GetRemoteUri());
732
733 GetEmptyData(option2);
734
735 LOG_INFO(UDMF_TEST, "SetData010 end.");
736 }
737
738 /**
739 * @tc.name: SetData011
740 * @tc.desc: Set SystemDefined record with valid params and get data
741 * @tc.type: FUNC
742 */
743 HWTEST_F(UdmfClientTest, SetData011, TestSize.Level1)
744 {
745 LOG_INFO(UDMF_TEST, "SetData011 begin.");
746
747 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
748 UnifiedData data1;
749 std::string key;
750 auto systemDefinedRecord1 = std::make_shared<SystemDefinedRecord>();
751 UDDetails details1;
752 details1.insert({ "udmf_key", "udmf_value" });
753 systemDefinedRecord1->SetDetails(details1);
754 data1.AddRecord(systemDefinedRecord1);
755 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
756 ASSERT_EQ(status, E_OK);
757
758 QueryOption option2 = { .key = key };
759 AddPrivilege(option2);
760 SetHapToken2();
761 UnifiedData data2;
762 status = UdmfClient::GetInstance().GetData(option2, data2);
763 ASSERT_EQ(status, E_OK);
764
765 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
766 ASSERT_NE(record2, nullptr);
767 auto type = record2->GetType();
768 ASSERT_EQ(type, UDType::SYSTEM_DEFINED_RECORD);
769
770 auto systemDefinedRecord2 = static_cast<SystemDefinedRecord *>(record2.get());
771 ASSERT_NE(systemDefinedRecord2, nullptr);
772 CompareDetails(systemDefinedRecord2->GetDetails());
773
774 GetEmptyData(option2);
775
776 LOG_INFO(UDMF_TEST, "SetData011 end.");
777 }
778
779 /**
780 * @tc.name: SetData012
781 * @tc.desc: Set Form record with valid params and get data
782 * @tc.type: FUNC
783 */
784 HWTEST_F(UdmfClientTest, SetData012, TestSize.Level1)
785 {
786 LOG_INFO(UDMF_TEST, "SetData012 begin.");
787
788 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
789 UnifiedData data1;
790 std::string key;
791 auto systemDefinedForm1 = std::make_shared<SystemDefinedForm>();
792 UDDetails details1;
793 details1.insert({ "udmf_key", "udmf_value" });
794 systemDefinedForm1->SetDetails(details1);
795 systemDefinedForm1->SetFormId(123);
796 systemDefinedForm1->SetFormName("formName");
797 systemDefinedForm1->SetModule("module");
798 systemDefinedForm1->SetAbilityName("abilityName");
799 systemDefinedForm1->SetBundleName("bundleName");
800 data1.AddRecord(systemDefinedForm1);
801 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
802 ASSERT_EQ(status, E_OK);
803
804 QueryOption option2 = { .key = key };
805 AddPrivilege(option2);
806 SetHapToken2();
807 UnifiedData data2;
808 status = UdmfClient::GetInstance().GetData(option2, data2);
809 ASSERT_EQ(status, E_OK);
810
811 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
812 ASSERT_NE(record2, nullptr);
813 auto type = record2->GetType();
814 ASSERT_EQ(type, UDType::SYSTEM_DEFINED_FORM);
815
816 auto systemDefinedRecord2 = static_cast<SystemDefinedRecord *>(record2.get());
817 ASSERT_NE(systemDefinedRecord2, nullptr);
818 CompareDetails(systemDefinedRecord2->GetDetails());
819
820 auto systemDefinedForm2 = static_cast<SystemDefinedForm *>(record2.get());
821 ASSERT_NE(systemDefinedForm2, nullptr);
822 EXPECT_EQ(systemDefinedForm1->GetFormId(), systemDefinedForm2->GetFormId());
823 EXPECT_EQ(systemDefinedForm1->GetFormName(), systemDefinedForm2->GetFormName());
824 EXPECT_EQ(systemDefinedForm1->GetBundleName(), systemDefinedForm2->GetBundleName());
825 EXPECT_EQ(systemDefinedForm1->GetAbilityName(), systemDefinedForm2->GetAbilityName());
826 EXPECT_EQ(systemDefinedForm1->GetModule(), systemDefinedForm2->GetModule());
827
828 GetEmptyData(option2);
829
830 LOG_INFO(UDMF_TEST, "SetData012 end.");
831 }
832
833 /**
834 * @tc.name: SetData013
835 * @tc.desc: Set AppItem record with valid params and get data
836 * @tc.type: FUNC
837 */
838 HWTEST_F(UdmfClientTest, SetData013, TestSize.Level1)
839 {
840 LOG_INFO(UDMF_TEST, "SetData013 begin.");
841
842 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
843 UnifiedData data1;
844 std::string key;
845 auto systemDefinedAppItem1 = std::make_shared<SystemDefinedAppItem>();
846 UDDetails details1;
847 details1.insert({ "udmf_key", "udmf_value" });
848 systemDefinedAppItem1->SetDetails(details1);
849 systemDefinedAppItem1->SetAppId("appId");
850 systemDefinedAppItem1->SetAppName("appName");
851 systemDefinedAppItem1->SetAppIconId("appIconId");
852 systemDefinedAppItem1->SetAppLabelId("appLabelId");
853 systemDefinedAppItem1->SetBundleName("bundleName");
854 systemDefinedAppItem1->SetAbilityName("abilityName");
855 data1.AddRecord(systemDefinedAppItem1);
856 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
857 ASSERT_EQ(status, E_OK);
858
859 QueryOption option2 = { .key = key };
860 AddPrivilege(option2);
861 SetHapToken2();
862 UnifiedData data2;
863 status = UdmfClient::GetInstance().GetData(option2, data2);
864 ASSERT_EQ(status, E_OK);
865
866 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
867 ASSERT_NE(record2, nullptr);
868 auto type = record2->GetType();
869 ASSERT_EQ(type, UDType::SYSTEM_DEFINED_APP_ITEM);
870
871 auto systemDefinedRecord2 = static_cast<SystemDefinedRecord *>(record2.get());
872 ASSERT_NE(systemDefinedRecord2, nullptr);
873 CompareDetails(systemDefinedRecord2->GetDetails());
874
875 auto systemDefinedAppItem2 = static_cast<SystemDefinedAppItem *>(record2.get());
876 ASSERT_NE(systemDefinedAppItem2, nullptr);
877 EXPECT_EQ(systemDefinedAppItem1->GetAppId(), systemDefinedAppItem2->GetAppId());
878 EXPECT_EQ(systemDefinedAppItem1->GetAppName(), systemDefinedAppItem2->GetAppName());
879 EXPECT_EQ(systemDefinedAppItem1->GetBundleName(), systemDefinedAppItem2->GetBundleName());
880 EXPECT_EQ(systemDefinedAppItem1->GetAbilityName(), systemDefinedAppItem2->GetAbilityName());
881 EXPECT_EQ(systemDefinedAppItem1->GetAppIconId(), systemDefinedAppItem2->GetAppIconId());
882 EXPECT_EQ(systemDefinedAppItem1->GetAppLabelId(), systemDefinedAppItem2->GetAppLabelId());
883
884 GetEmptyData(option2);
885
886 LOG_INFO(UDMF_TEST, "SetData013 end.");
887 }
888
889 /**
890 * @tc.name: SetData014
891 * @tc.desc: Set PixelMap record with valid params and get data
892 * @tc.type: FUNC
893 */
894 HWTEST_F(UdmfClientTest, SetData014, TestSize.Level1)
895 {
896 LOG_INFO(UDMF_TEST, "SetData014 begin.");
897
898 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
899 UnifiedData data1;
900 std::string key;
901 auto systemDefinedPixelMap1 = std::make_shared<SystemDefinedPixelMap>();
902 UDDetails details1;
903 details1.insert({ "udmf_key", "udmf_value" });
904 systemDefinedPixelMap1->SetDetails(details1);
905 std::vector<uint8_t> rawData1;
906
907 uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
908 OHOS::Media::InitializationOptions opts = { { 5, 7 },
909 Media::PixelFormat::ARGB_8888,
910 Media::PixelFormat::ARGB_8888 };
911 std::unique_ptr<OHOS::Media::PixelMap> pixelMap =
912 OHOS::Media::PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
913 std::shared_ptr<OHOS::Media::PixelMap> pixelMapIn = move(pixelMap);
914 pixelMapIn->EncodeTlv(rawData1);
915
916 systemDefinedPixelMap1->SetRawData(rawData1);
917 data1.AddRecord(systemDefinedPixelMap1);
918 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
919 ASSERT_EQ(status, E_OK);
920
921 QueryOption option2 = { .key = key };
922 AddPrivilege(option2);
923 SetHapToken2();
924 UnifiedData data2;
925 status = UdmfClient::GetInstance().GetData(option2, data2);
926 ASSERT_EQ(status, E_OK);
927
928 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
929 ASSERT_NE(record2, nullptr);
930 auto type = record2->GetType();
931 ASSERT_EQ(type, UDType::SYSTEM_DEFINED_PIXEL_MAP);
932
933 auto systemDefinedRecord2 = static_cast<SystemDefinedRecord *>(record2.get());
934 ASSERT_NE(systemDefinedRecord2, nullptr);
935 ComparePixelMap(systemDefinedRecord2->GetDetails(), pixelMapIn);
936
937 auto systemDefinedPixelMap2 = static_cast<SystemDefinedPixelMap *>(record2.get());
938 ASSERT_NE(systemDefinedPixelMap2, nullptr);
939 auto rawData2 = systemDefinedPixelMap2->GetRawData();
940 EXPECT_EQ(rawData1.size(), rawData2.size());
941 for (uint32_t i = 0; i < rawData1.size(); ++i) {
942 EXPECT_EQ(rawData1[i], rawData2[i]);
943 }
944
945 GetEmptyData(option2);
946
947 LOG_INFO(UDMF_TEST, "SetData014 end.");
948 }
949
950 /**
951 * @tc.name: SetData015
952 * @tc.desc: Set Application Defined record with valid params and get data
953 * @tc.type: FUNC
954 */
955 HWTEST_F(UdmfClientTest, SetData015, TestSize.Level1)
956 {
957 LOG_INFO(UDMF_TEST, "SetData015 begin.");
958
959 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
960 UnifiedData data1;
961 std::string key;
962 auto applicationDefinedRecord1 = std::make_shared<ApplicationDefinedRecord>();
963 applicationDefinedRecord1->SetApplicationDefinedType("applicationDefinedType");
964 std::vector<uint8_t> rawData1 = { 1, 2, 3, 4, 5 };
965 applicationDefinedRecord1->SetRawData(rawData1);
966 data1.AddRecord(applicationDefinedRecord1);
967 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
968 ASSERT_EQ(status, E_OK);
969
970 QueryOption option2 = { .key = key };
971 AddPrivilege(option2);
972 SetHapToken2();
973 UnifiedData data2;
974 status = UdmfClient::GetInstance().GetData(option2, data2);
975 ASSERT_EQ(status, E_OK);
976
977 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
978 ASSERT_NE(record2, nullptr);
979 auto type = record2->GetType();
980 ASSERT_EQ(type, UDType::APPLICATION_DEFINED_RECORD);
981
982 auto applicationDefinedRecord2 = static_cast<ApplicationDefinedRecord *>(record2.get());
983 ASSERT_NE(applicationDefinedRecord2, nullptr);
984 EXPECT_EQ(applicationDefinedRecord1->GetApplicationDefinedType(),
985 applicationDefinedRecord2->GetApplicationDefinedType());
986 auto rawData2 = applicationDefinedRecord2->GetRawData();
987 EXPECT_EQ(rawData1.size(), rawData2.size());
988 for (uint32_t i = 0; i < rawData1.size(); ++i) {
989 EXPECT_EQ(rawData1[i], rawData2[i]);
990 }
991
992 GetEmptyData(option2);
993
994 LOG_INFO(UDMF_TEST, "SetData015 end.");
995 }
996
997 /**
998 * @tc.name: SetData016
999 * @tc.desc: Set multiple record with valid params and get data
1000 * @tc.type: FUNC
1001 */
1002 HWTEST_F(UdmfClientTest, SetData016, TestSize.Level1)
1003 {
1004 LOG_INFO(UDMF_TEST, "SetData016 begin.");
1005
1006 CustomOption customOption = {.intention = Intention::UD_INTENTION_DRAG};
1007 std::string key;
1008 UnifiedData inputData;
1009 std::vector<std::shared_ptr<UnifiedRecord>> inputRecords = {
1010 std::make_shared<Text>(),
1011 std::make_shared<PlainText>(),
1012 std::make_shared<File>(),
1013 std::make_shared<Image>(),
1014 std::make_shared<SystemDefinedRecord>(),
1015 std::make_shared<SystemDefinedForm>(),
1016 std::make_shared<ApplicationDefinedRecord>()
1017 };
1018 inputData.SetRecords(inputRecords);
1019
1020 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
1021 ASSERT_EQ(status, E_OK);
1022
1023 QueryOption queryOption = { .key = key };
1024 UnifiedData outputData;
1025 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
1026 ASSERT_EQ(status, E_OK);
1027 auto outputRecords = outputData.GetRecords();
1028 ASSERT_EQ(inputRecords.size(), outputRecords.size());
1029 for (size_t i = 0; i < outputRecords.size(); ++i) {
1030 ASSERT_EQ(outputRecords[i]->GetType(), inputRecords[i]->GetType());
1031 }
1032
1033 LOG_INFO(UDMF_TEST, "SetData016 end.");
1034 }
1035
1036 /**
1037 * @tc.name: SetData017
1038 * @tc.desc: Set 512 records with valid params and get data
1039 * @tc.type: FUNC
1040 */
1041 HWTEST_F(UdmfClientTest, SetData017, TestSize.Level1)
1042 {
1043 LOG_INFO(UDMF_TEST, "SetData017 begin.");
1044
1045 CustomOption customOption = {.intention = Intention::UD_INTENTION_DRAG};
1046 std::string key;
1047 UnifiedData inputData;
1048 std::vector<std::shared_ptr<UnifiedRecord>> inputRecords;
1049 for (int32_t i = 0; i < 512; ++i) {
1050 inputRecords.emplace_back(std::make_shared<Text>());
1051 }
1052 inputData.SetRecords(inputRecords);
1053
1054 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
1055 ASSERT_EQ(status, E_OK);
1056
1057 QueryOption queryOption = { .key = key };
1058 UnifiedData outputData;
1059 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
1060 ASSERT_EQ(status, E_OK);
1061 auto outputRecords = outputData.GetRecords();
1062 ASSERT_EQ(inputRecords.size(), outputRecords.size());
1063
1064 LOG_INFO(UDMF_TEST, "SetData017 end.");
1065 }
1066
1067 /**
1068 * @tc.name: SetData018
1069 * @tc.desc: Set one 2MB record of data with valid params and get data
1070 * @tc.type: FUNC
1071 */
1072 HWTEST_F(UdmfClientTest, SetData018, TestSize.Level1)
1073 {
1074 LOG_INFO(UDMF_TEST, "SetData018 begin.");
1075
1076 CustomOption customOption = { .intention = Intention::UD_INTENTION_DRAG };
1077 UnifiedData inputData;
1078 std::string key;
1079 UDDetails details;
1080 std::string value;
1081 int64_t maxSize = 512 * 1024;
1082 for (int64_t i = 0; i < maxSize; ++i) {
1083 value += "11";
1084 }
1085 details.insert({ value, value });
1086 auto text = std::make_shared<Text>();
1087 text->SetDetails(details);
1088 inputData.AddRecord(text);
1089
1090 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
1091 ASSERT_EQ(status, E_OK);
1092
1093 QueryOption queryOption = { .key = key };
1094 UnifiedData outputData;
1095 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
1096 ASSERT_EQ(status, E_OK);
1097
1098 LOG_INFO(UDMF_TEST, "SetData018 end.");
1099 }
1100
1101 /**
1102 * @tc.name: SetData019
1103 * @tc.desc: Set one over 2MB record of data with valid params and get data
1104 * @tc.type: FUNC
1105 */
1106 HWTEST_F(UdmfClientTest, SetData019, TestSize.Level1)
1107 {
1108 LOG_INFO(UDMF_TEST, "SetData019 begin.");
1109
1110 CustomOption customOption = { .intention = Intention::UD_INTENTION_DRAG };
1111 UnifiedData inputData;
1112 std::string key;
1113 UDDetails details;
1114 std::string value;
1115 int64_t maxSize = 512 * 1024;
1116 for (int64_t i = 0; i < maxSize; ++i) {
1117 value += "11";
1118 }
1119 details.insert({ value, value });
1120 details.insert({ "udmf_key", "udmf_value" });
1121 auto text = std::make_shared<Text>();
1122 text->SetDetails(details);
1123 inputData.AddRecord(text);
1124
1125 UnifiedDataHelper::SetRootPath("/data/udmf_test/");
1126 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
1127 ASSERT_EQ(status, E_OK);
1128
1129 QueryOption queryOption = { .key = key };
1130 UnifiedData outputData;
1131 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
1132 ASSERT_EQ(status, E_OK);
1133 UnifiedDataHelper::SetRootPath("");
1134
1135 LOG_INFO(UDMF_TEST, "SetData019 end.");
1136 }
1137
1138 /**
1139 * @tc.name: SetData020
1140 * @tc.desc: Set two 2MB record of data with valid params and get data
1141 * @tc.type: FUNC
1142 */
1143 HWTEST_F(UdmfClientTest, SetData020, TestSize.Level1)
1144 {
1145 LOG_INFO(UDMF_TEST, "SetData020 begin.");
1146
1147 CustomOption customOption = { .intention = Intention::UD_INTENTION_DRAG };
1148 UnifiedData inputData;
1149 std::string key;
1150 UDDetails details;
1151 std::string value;
1152 int64_t maxSize = 512 * 1024;
1153 for (int64_t i = 0; i < maxSize; ++i) {
1154 value += "11";
1155 }
1156 details.insert({ value, value });
1157 auto text = std::make_shared<Text>();
1158 text->SetDetails(details);
1159 for (int i = 0; i < 2; ++i) {
1160 inputData.AddRecord(text);
1161 }
1162 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
1163 ASSERT_EQ(status, E_OK);
1164
1165 QueryOption queryOption = { .key = key };
1166 UnifiedData outputData;
1167 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
1168 ASSERT_EQ(status, E_OK);
1169
1170 LOG_INFO(UDMF_TEST, "SetData020 end.");
1171 }
1172
1173 /**
1174 * @tc.name: GetData001
1175 * @tc.desc: Get data with invalid key
1176 * @tc.type: FUNC
1177 */
1178 HWTEST_F(UdmfClientTest, GetData001, TestSize.Level1)
1179 {
1180 LOG_INFO(UDMF_TEST, "GetData001 begin.");
1181
1182 QueryOption option;
1183 UnifiedData data;
1184 auto status = UdmfClient::GetInstance().GetData(option, data);
1185 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1186
1187 option.key = "udmf";
1188 status = UdmfClient::GetInstance().GetData(option, data);
1189 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1190
1191 option.key = "odmf://";
1192 status = UdmfClient::GetInstance().GetData(option, data);
1193 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1194
1195 option.key = "udmf://drag";
1196 status = UdmfClient::GetInstance().GetData(option, data);
1197 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1198
1199 option.key = "udmf://123/bundle/group";
1200 status = UdmfClient::GetInstance().GetData(option, data);
1201 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1202
1203 option.key = "udmf://drag/bundle";
1204 status = UdmfClient::GetInstance().GetData(option, data);
1205 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1206
1207 option.key = "udmf://drag/bundle***/group";
1208 status = UdmfClient::GetInstance().GetData(option, data);
1209 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1210
1211 option.key = "udmf://drag/bundle/";
1212 status = UdmfClient::GetInstance().GetData(option, data);
1213 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1214
1215 option.key = "udmf://drag/bundle/group###";
1216 status = UdmfClient::GetInstance().GetData(option, data);
1217 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1218
1219 LOG_INFO(UDMF_TEST, "GetData001 end.");
1220 }
1221
1222 /**
1223 * @tc.name: GetSummary001
1224 * @tc.desc: Get summary data
1225 * @tc.type: FUNC
1226 */
1227 HWTEST_F(UdmfClientTest, GetSummary001, TestSize.Level1)
1228 {
1229 LOG_INFO(UDMF_TEST, "GetSummary001 begin.");
1230
1231 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
1232 UnifiedData data;
1233 std::string key;
1234
1235 UDDetails details;
1236 details.insert({ "udmf_key", "udmf_value" });
1237
1238 auto text = std::make_shared<Text>();
1239 text->SetDetails(details);
1240 data.AddRecord(text);
1241
1242 auto plainText = std::make_shared<PlainText>();
1243 plainText->SetDetails(details);
1244 plainText->SetContent("content");
1245 plainText->SetAbstract("abstract");
1246 data.AddRecord(plainText);
1247
1248 auto file = std::make_shared<File>();
1249 file->SetDetails(details);
1250 file->SetUri("uri");
1251 file->SetRemoteUri("remoteUri");
1252 data.AddRecord(file);
1253
1254 auto image = std::make_shared<Image>();
1255 file->SetDetails(details);
1256 image->SetUri("uri");
1257 image->SetRemoteUri("remoteUri");
1258 data.AddRecord(image);
1259
1260 auto systemDefinedRecord = std::make_shared<SystemDefinedRecord>();
1261 systemDefinedRecord->SetDetails(details);
1262 data.AddRecord(systemDefinedRecord);
1263
1264 auto systemDefinedForm = std::make_shared<SystemDefinedForm>();
1265 systemDefinedForm->SetDetails(details);
1266 systemDefinedForm->SetFormId(123);
1267 systemDefinedForm->SetFormName("formName");
1268 systemDefinedForm->SetModule("module");
1269 systemDefinedForm->SetAbilityName("abilityName");
1270 systemDefinedForm->SetBundleName("bundleName");
1271 data.AddRecord(systemDefinedForm);
1272
1273 auto applicationDefinedRecord = std::make_shared<ApplicationDefinedRecord>();
1274 applicationDefinedRecord->SetApplicationDefinedType("applicationDefinedType");
1275 std::vector<uint8_t> rawData = { 1, 2, 3, 4, 5 };
1276 applicationDefinedRecord->SetRawData(rawData);
1277 data.AddRecord(applicationDefinedRecord);
1278
1279 std::shared_ptr<Object> obj = std::make_shared<Object>();
1280 obj->value_[UNIFORM_DATA_TYPE] = "general.file-uri";
1281 obj->value_[FILE_URI_PARAM] = "http://demo.com";
1282 obj->value_[FILE_TYPE] = "abcdefg";
1283 auto record8 = std::make_shared<UnifiedRecord>(FILE_URI, obj);
1284 data.AddRecord(record8);
1285
1286 auto record9 = std::make_shared<UnifiedRecord>(PNG, "http://demo.com");
1287 data.AddRecord(record9);
1288
1289 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
1290 ASSERT_EQ(status, E_OK);
1291
1292 QueryOption option2 = { .key = key };
1293 Summary summary;
1294 status = UdmfClient::GetInstance().GetSummary(option2, summary);
1295
1296 auto size = text->GetSize();
1297 size += plainText->GetSize();
1298 size += file->GetSize();
1299 size += image->GetSize();
1300 size += systemDefinedRecord->GetSize();
1301 size += systemDefinedForm->GetSize();
1302 size += applicationDefinedRecord->GetSize();
1303 size += record8->GetSize();
1304 size += record9->GetSize();
1305
1306 EXPECT_EQ(status, E_OK);
1307 EXPECT_EQ(summary.totalSize, size);
1308 EXPECT_EQ(summary.summary["general.text"], text->GetSize());
1309 EXPECT_EQ(summary.summary["general.plain-text"], plainText->GetSize());
1310 EXPECT_EQ(summary.summary["general.file"], file->GetSize() + record8->GetSize());
1311 EXPECT_EQ(summary.summary["general.image"], image->GetSize());
1312 EXPECT_EQ(summary.summary["SystemDefinedType"], systemDefinedRecord->GetSize());
1313 EXPECT_EQ(summary.summary["openharmony.form"], systemDefinedForm->GetSize());
1314 EXPECT_EQ(summary.summary["ApplicationDefinedType"], applicationDefinedRecord->GetSize());
1315 EXPECT_EQ(summary.summary["abcdefg"], 0);
1316 EXPECT_EQ(summary.summary["general.png"], record9->GetSize());
1317
1318 LOG_INFO(UDMF_TEST, "GetSummary001 end.");
1319 }
1320
1321
1322 /**
1323 * @tc.name: GetSummary002
1324 * @tc.desc: Get summary with invalid key
1325 * @tc.type: FUNC
1326 */
1327 HWTEST_F(UdmfClientTest, GetSummary002, TestSize.Level1)
1328 {
1329 LOG_INFO(UDMF_FRAMEWORK, "GetSummary002 begin.");
1330
1331 QueryOption option;
1332 Summary summary;
1333 auto status = UdmfClient::GetInstance().GetSummary(option, summary);
1334 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1335
1336 option.key = "udmf";
1337 status = UdmfClient::GetInstance().GetSummary(option, summary);
1338 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1339
1340 option.key = "odmf://";
1341 status = UdmfClient::GetInstance().GetSummary(option, summary);
1342 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1343
1344 option.key = "udmf://drag";
1345 status = UdmfClient::GetInstance().GetSummary(option, summary);
1346 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1347
1348 option.key = "udmf://123/bundle/group";
1349 status = UdmfClient::GetInstance().GetSummary(option, summary);
1350 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1351
1352 option.key = "udmf://drag/bundle";
1353 status = UdmfClient::GetInstance().GetSummary(option, summary);
1354 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1355
1356 option.key = "udmf://drag/bundle***/group";
1357 status = UdmfClient::GetInstance().GetSummary(option, summary);
1358 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1359
1360 option.key = "udmf://drag/bundle/";
1361 status = UdmfClient::GetInstance().GetSummary(option, summary);
1362 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1363
1364 option.key = "udmf://drag/bundle/group###";
1365 status = UdmfClient::GetInstance().GetSummary(option, summary);
1366 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1367
1368 LOG_INFO(UDMF_FRAMEWORK, "GetSummary002 end.");
1369 }
1370
1371 /**
1372 * @tc.name: AddPrivilege001
1373 * @tc.desc: Add privilege with valid params
1374 * @tc.type: FUNC
1375 */
1376 HWTEST_F(UdmfClientTest, AddPrivilege001, TestSize.Level1)
1377 {
1378 LOG_INFO(UDMF_TEST, "AddPrivilege001 begin.");
1379
1380 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
1381 UnifiedData data;
1382 auto text = std::make_shared<Text>();
1383 UDDetails details;
1384 details.insert({ "udmf_key", "udmf_value" });
1385 text->SetDetails(details);
1386 data.AddRecord(text);
1387 std::string key;
1388 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
1389 ASSERT_EQ(status, E_OK);
1390
1391 QueryOption option2 = { .key = key };
1392 Privilege privilege;
1393 SetHapToken2();
1394 privilege.tokenId = AccessTokenKit::GetHapTokenID(100, "ohos.test.demo2", 0);
1395 privilege.readPermission = "readPermission";
1396 privilege.writePermission = "writePermission";
1397 SetNativeToken("msdp_sa");
1398 status = UdmfClient::GetInstance().AddPrivilege(option2, privilege);
1399 ASSERT_EQ(status, E_OK);
1400
1401 LOG_INFO(UDMF_TEST, "AddPrivilege001 end.");
1402 }
1403
1404 /**
1405 * @tc.name: AddPrivilege002
1406 * @tc.desc: Add Privilege with invalid params
1407 * @tc.type: FUNC
1408 */
1409 HWTEST_F(UdmfClientTest, AddPrivilege002, TestSize.Level1)
1410 {
1411 LOG_INFO(UDMF_FRAMEWORK, "AddPrivilege002 begin.");
1412
1413 QueryOption option;
1414 Privilege privilege;
1415 auto status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1416 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1417
1418 option.key = "udmf";
1419 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1420 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1421
1422 option.key = "odmf://";
1423 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1424 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1425
1426 option.key = "udmf://drag";
1427 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1428 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1429
1430 option.key = "udmf://123/bundle/group";
1431 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1432 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1433
1434 option.key = "udmf://drag/bundle";
1435 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1436 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1437
1438 option.key = "udmf://drag/bundle***/group";
1439 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1440 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1441
1442 option.key = "udmf://drag/bundle/";
1443 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1444 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1445
1446 option.key = "udmf://drag/bundle/group###";
1447 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1448 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1449
1450 LOG_INFO(UDMF_FRAMEWORK, "AddPrivilege002 end.");
1451 }
1452
1453 /**
1454 * @tc.name: AddPrivilege003
1455 * @tc.desc: Add privilege with invalid intention
1456 * @tc.type: FUNC
1457 */
1458 HWTEST_F(UdmfClientTest, AddPrivilege003, TestSize.Level1)
1459 {
1460 LOG_INFO(UDMF_TEST, "AddPrivilege003 begin.");
1461
1462 CustomOption option1 = { .intention = Intention::UD_INTENTION_DATA_HUB };
1463 UnifiedData data;
1464 auto text = std::make_shared<Text>();
1465 UDDetails details;
1466 details.insert({ "udmf_key", "udmf_value" });
1467 text->SetDetails(details);
1468 data.AddRecord(text);
1469 std::string key;
1470 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
1471 ASSERT_EQ(status, E_OK);
1472
1473 QueryOption option2 = { .key = key };
1474 Privilege privilege;
1475 SetHapToken2();
1476 privilege.tokenId = AccessTokenKit::GetHapTokenID(100, "ohos.test.demo2", 0);
1477 privilege.readPermission = "readPermission";
1478 privilege.writePermission = "writePermission";
1479 SetNativeToken("msdp_sa");
1480 status = UdmfClient::GetInstance().AddPrivilege(option2, privilege);
1481 ASSERT_EQ(status, E_NO_PERMISSION);
1482 LOG_INFO(UDMF_TEST, "AddPrivilege003 end.");
1483 }
1484
1485 /**
1486 * @tc.name: AddPrivilege004
1487 * @tc.desc: Add privilege for unauthorized process with valid params
1488 * @tc.type: FUNC
1489 */
1490 HWTEST_F(UdmfClientTest, AddPrivilege004, TestSize.Level1)
1491 {
1492 LOG_INFO(UDMF_TEST, "AddPrivilege004 begin.");
1493
1494 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
1495 UnifiedData data;
1496 auto text = std::make_shared<Text>();
1497 UDDetails details;
1498 details.insert({ "udmf_key", "udmf_value" });
1499 text->SetDetails(details);
1500 data.AddRecord(text);
1501 std::string key;
1502 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
1503 ASSERT_EQ(status, E_OK);
1504
1505 QueryOption option2 = { .key = key };
1506 Privilege privilege;
1507 SetHapToken2();
1508 privilege.tokenId = AccessTokenKit::GetHapTokenID(100, "ohos.test.demo2", 0);
1509 privilege.readPermission = "readPermission";
1510 privilege.writePermission = "writePermission";
1511 SetNativeToken("foundation");
1512 status = UdmfClient::GetInstance().AddPrivilege(option2, privilege);
1513 ASSERT_EQ(status, E_NO_PERMISSION);
1514 LOG_INFO(UDMF_TEST, "AddPrivilege004 end.");
1515 }
1516
1517 /**
1518 * @tc.name: AddPrivilege005
1519 * @tc.desc: Add privilege with valid params
1520 * @tc.type: FUNC
1521 */
1522 HWTEST_F(UdmfClientTest, AddPrivilege005, TestSize.Level1)
1523 {
1524 LOG_INFO(UDMF_TEST, "AddPrivilege005 begin.");
1525
1526 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
1527 UnifiedData data;
1528 auto text = std::make_shared<Text>();
1529 UDDetails details;
1530 details.insert({ "udmf_key", "udmf_value" });
1531 text->SetDetails(details);
1532 data.AddRecord(text);
1533 std::string key;
1534 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
1535 ASSERT_EQ(status, E_OK);
1536
1537 QueryOption option2 = { .key = key };
1538 Privilege privilege;
1539 SetHapToken2();
1540 privilege.tokenId = AccessTokenKit::GetHapTokenID(100, "ohos.test.demo2", 0);
1541 privilege.readPermission = "readAndKeep";
1542 privilege.writePermission = "writePermission";
1543 SetNativeToken("msdp_sa");
1544 status = UdmfClient::GetInstance().AddPrivilege(option2, privilege);
1545 ASSERT_EQ(status, E_OK);
1546
1547 SetHapToken2();
1548 UnifiedData data1;
1549 status = UdmfClient::GetInstance().GetData(option2, data1);
1550 ASSERT_EQ(status, E_OK);
1551
1552 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
1553 UnifiedData data2;
1554 status = UdmfClient::GetInstance().GetData(option2, data2);
1555 ASSERT_EQ(status, E_OK);
1556 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
1557 ASSERT_NE(record2, nullptr);
1558 auto type = record2->GetType();
1559 ASSERT_EQ(type, UDType::TEXT);
1560 auto text2 = static_cast<Text *>(record2.get());
1561 ASSERT_NE(text2, nullptr);
1562 CompareDetails(text2->GetDetails()); // Can be read repeatedly.
1563 LOG_INFO(UDMF_TEST, "AddPrivilege005 end.");
1564 }
1565
1566 /**
1567 * @tc.name: GetSelfData001
1568 * @tc.desc: Set File record with valid params and no add privilege and get data by self
1569 * @tc.type: FUNC
1570 */
1571 HWTEST_F(UdmfClientTest, GetSelfData001, TestSize.Level1)
1572 {
1573 LOG_INFO(UDMF_TEST, "GetSelfData001 begin.");
1574
1575 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
1576 UnifiedData data1;
1577 std::string key;
1578 auto file1 = std::make_shared<File>();
1579 file1->SetRemoteUri("remoteUri");
1580 UDDetails details1;
1581 details1.insert({ "udmf_key", "udmf_value" });
1582 file1->SetDetails(details1);
1583 data1.AddRecord(file1);
1584 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
1585 ASSERT_EQ(status, E_OK);
1586
1587 QueryOption option2 = { .key = key };
1588 UnifiedData data2;
1589 status = UdmfClient::GetInstance().GetData(option2, data2);
1590 ASSERT_EQ(status, E_OK);
1591
1592 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
1593 ASSERT_NE(record2, nullptr);
1594 auto type = record2->GetType();
1595 ASSERT_EQ(type, UDType::FILE);
1596
1597 auto file2 = static_cast<File *>(record2.get());
1598 ASSERT_NE(file2, nullptr);
1599 EXPECT_EQ(file1->GetRemoteUri(), file2->GetRemoteUri());
1600 CompareDetails(file2->GetDetails());
1601
1602 GetEmptyData(option2);
1603
1604 LOG_INFO(UDMF_TEST, "GetSelfData001 end.");
1605 }
1606
1607 /**
1608 * @tc.name: GetSelfData002
1609 * @tc.desc: Set File record with valid params and add privilege and get data by self
1610 * @tc.type: FUNC
1611 */
1612 HWTEST_F(UdmfClientTest, GetSelfData002, TestSize.Level1)
1613 {
1614 LOG_INFO(UDMF_TEST, "GetSelfData002 begin.");
1615
1616 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
1617 UnifiedData data1;
1618 std::string key;
1619 auto file1 = std::make_shared<File>();
1620 file1->SetRemoteUri("remoteUri");
1621 UDDetails details1;
1622 details1.insert({ "udmf_key", "udmf_value" });
1623 file1->SetDetails(details1);
1624 data1.AddRecord(file1);
1625 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
1626 ASSERT_EQ(status, E_OK);
1627
1628 QueryOption option2 = { .key = key };
1629 AddPrivilege(option2);
1630 SetHapToken1();
1631 UnifiedData data2;
1632 status = UdmfClient::GetInstance().GetData(option2, data2);
1633 ASSERT_EQ(status, E_OK);
1634
1635 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
1636 ASSERT_NE(record2, nullptr);
1637 auto type = record2->GetType();
1638 ASSERT_EQ(type, UDType::FILE);
1639
1640 auto file2 = static_cast<File *>(record2.get());
1641 ASSERT_NE(file2, nullptr);
1642 EXPECT_EQ(file1->GetRemoteUri(), file2->GetRemoteUri());
1643 CompareDetails(file2->GetDetails());
1644
1645 GetEmptyData(option2);
1646
1647 LOG_INFO(UDMF_TEST, "GetSelfData002 end.");
1648 }
1649
1650 /**
1651 * @tc.name: SetData021
1652 * @tc.desc: Set datas with intention ${UD_INTENTION_DATA_HUB} and manually check db is cleared before set or not
1653 * @tc.type: FUNC
1654 */
1655 HWTEST_F(UdmfClientTest, SetData021, TestSize.Level1)
1656 {
1657 LOG_INFO(UDMF_TEST, "SetData021 begin.");
1658 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
1659 std::vector<UnifiedData> unifiedDataSet;
1660 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
1661 ASSERT_EQ(status, E_OK);
1662 unifiedDataSet.clear();
1663 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
1664 ASSERT_EQ(status, E_OK);
1665 auto originSize = unifiedDataSet.size();
1666 unifiedDataSet.clear();
1667
1668 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
1669 UnifiedData data1;
1670 auto plainText1 = std::make_shared<PlainText>();
1671 plainText1->SetContent("content1");
1672 data1.AddRecord(plainText1);
1673 std::string key;
1674 status = UdmfClient::GetInstance().SetData(customOption, data1, key);
1675 ASSERT_EQ(status, E_OK);
1676 UnifiedData data2;
1677 plainText1->SetContent("content2");
1678 data2.AddRecord(plainText1);
1679 status = UdmfClient::GetInstance().SetData(customOption, data2, key);
1680 ASSERT_EQ(status, E_OK);
1681
1682 SetHapToken2();
1683 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
1684 ASSERT_EQ(status, E_OK);
1685 ASSERT_EQ(unifiedDataSet.size(), originSize + 2);
1686 LOG_INFO(UDMF_TEST, "SetData021 end.");
1687 }
1688
1689 /**
1690 * @tc.name: UpdateData001
1691 * @tc.desc: Update data with invalid params
1692 * @tc.type: FUNC
1693 */
1694 HWTEST_F(UdmfClientTest, UpdateData001, TestSize.Level1)
1695 {
1696 LOG_INFO(UDMF_TEST, "UpdateData001 begin.");
1697
1698 UnifiedData data;
1699 QueryOption queryOption = { .key = "" };
1700 auto status = UdmfClient::GetInstance().UpdateData(queryOption, data);
1701 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1702
1703 queryOption = { .key = "udmf://drag/ohos.test.demo1/abcde" };
1704 status = UdmfClient::GetInstance().UpdateData(queryOption, data);
1705 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1706
1707 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
1708 UnifiedData data1;
1709 auto plainText1 = std::make_shared<PlainText>();
1710 plainText1->SetContent("content1");
1711 data1.AddRecord(plainText1);
1712 std::string key;
1713 status = UdmfClient::GetInstance().SetData(customOption, data1, key);
1714 ASSERT_EQ(status, E_OK);
1715
1716 queryOption = { .key = key };
1717 SetHapToken2();
1718 status = UdmfClient::GetInstance().UpdateData(queryOption, data);
1719 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1720 LOG_INFO(UDMF_TEST, "UpdateData001 end.");
1721 }
1722
1723 /**
1724 * @tc.name: UpdateData002
1725 * @tc.desc: Update data with valid params
1726 * @tc.type: FUNC
1727 */
1728 HWTEST_F(UdmfClientTest, UpdateData002, TestSize.Level1)
1729 {
1730 LOG_INFO(UDMF_TEST, "UpdateData002 begin.");
1731
1732 UnifiedData data;
1733 auto plainText = std::make_shared<PlainText>();
1734 plainText->SetContent("content");
1735 data.AddRecord(plainText);
1736
1737 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
1738 UnifiedData data1;
1739 auto plainText1 = std::make_shared<PlainText>();
1740 plainText1->SetContent("content1");
1741 data1.AddRecord(plainText1);
1742 std::string key;
1743 auto status = UdmfClient::GetInstance().SetData(customOption, data1, key);
1744
1745 ASSERT_EQ(status, E_OK);
1746 QueryOption queryOption = { .key = key };
1747 SetHapToken2();
1748 status = UdmfClient::GetInstance().UpdateData(queryOption, data);
1749 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1750
1751 SetHapToken1();
1752 status = UdmfClient::GetInstance().UpdateData(queryOption, data);
1753 ASSERT_EQ(status, E_OK);
1754
1755 std::vector<UnifiedData> dataSet;
1756 status = UdmfClient::GetInstance().GetBatchData(queryOption, dataSet);
1757 std::shared_ptr<UnifiedRecord> record2 = dataSet[0].GetRecordAt(0);
1758 ASSERT_NE(record2, nullptr);
1759 auto type = record2->GetType();
1760 ASSERT_EQ(type, UDType::PLAIN_TEXT);
1761 auto plainText2 = static_cast<PlainText *>(record2.get());
1762 ASSERT_EQ(plainText2->GetContent(), "content");
1763
1764 LOG_INFO(UDMF_TEST, "UpdateData002 end.");
1765 }
1766
1767 /**
1768 * @tc.name: OH_Udmf_GetBatchData001
1769 * @tc.desc: GetBatchData data with valid params
1770 * @tc.type: FUNC
1771 */
1772 HWTEST_F(UdmfClientTest, OH_Udmf_GetBatchData001, TestSize.Level1)
1773 {
1774 LOG_INFO(UDMF_TEST, "OH_Udmf_GetBatchData001 begin.");
1775
1776 UnifiedData data;
1777 auto plainText = std::make_shared<PlainText>();
1778 plainText->SetContent("content");
1779 data.AddRecord(plainText);
1780 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB,
1781 .visibility = Visibility::VISIBILITY_OWN_PROCESS };
1782 std::string key;
1783 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
1784 ASSERT_EQ(status, E_OK);
1785
1786 QueryOption queryOption = { .key = key, .intention = UD_INTENTION_DATA_HUB };
1787 std::vector<UnifiedData> dataSet;
1788 status = UdmfClient::GetInstance().GetBatchData(queryOption, dataSet);
1789 std::shared_ptr<UnifiedRecord> record = dataSet[0].GetRecordAt(0);
1790 ASSERT_NE(record, nullptr);
1791 auto type = record->GetType();
1792 ASSERT_EQ(type, UDType::PLAIN_TEXT);
1793 auto plainText2 = static_cast<PlainText *>(record.get());
1794 ASSERT_EQ(plainText2->GetContent(), "content");
1795 std::vector<UnifiedData> dataDelete;
1796 status = UdmfClient::GetInstance().DeleteData(queryOption, dataDelete);
1797 ASSERT_EQ(status, E_OK);
1798 LOG_INFO(UDMF_TEST, "OH_Udmf_GetBatchData001 end.");
1799 }
1800
1801 /**
1802 * @tc.name: OH_Udmf_GetBatchData002
1803 * @tc.desc: GetBatchData data with valid params
1804 * @tc.type: FUNC
1805 */
1806 HWTEST_F(UdmfClientTest, OH_Udmf_GetBatchData002, TestSize.Level1)
1807 {
1808 LOG_INFO(UDMF_TEST, "OH_Udmf_GetBatchData002 begin.");
1809 SetHapToken1();
1810 UnifiedData data;
1811 auto plainText = std::make_shared<PlainText>();
1812 plainText->SetContent("content");
1813 data.AddRecord(plainText);
1814 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB,
1815 .visibility = Visibility::VISIBILITY_OWN_PROCESS };
1816 std::string key;
1817 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
1818 ASSERT_EQ(status, E_OK);
1819
1820 SetHapToken2();
1821 QueryOption queryOption = { .key = key, .intention = UD_INTENTION_DATA_HUB };
1822 std::vector<UnifiedData> dataSet;
1823 status = UdmfClient::GetInstance().GetBatchData(queryOption, dataSet);
1824 ASSERT_EQ(status, E_OK);
1825 ASSERT_EQ(dataSet.size(), 0);
1826 SetHapToken1();
1827 std::vector<UnifiedData> dataDelete;
1828 status = UdmfClient::GetInstance().DeleteData(queryOption, dataDelete);
1829 ASSERT_EQ(status, E_OK);
1830 ASSERT_EQ(dataDelete.size(), 1);
1831 LOG_INFO(UDMF_TEST, "OH_Udmf_GetBatchData002 end.");
1832 }
1833
1834 /**
1835 * @tc.name: OH_Udmf_GetBatchData003
1836 * @tc.desc: GetBatchData data with valid params
1837 * @tc.type: FUNC
1838 */
1839 HWTEST_F(UdmfClientTest, OH_Udmf_GetBatchData003, TestSize.Level1)
1840 {
1841 LOG_INFO(UDMF_TEST, "OH_Udmf_GetBatchData003 begin.");
1842
1843 UnifiedData data;
1844 auto plainText = std::make_shared<PlainText>();
1845 plainText->SetContent("content");
1846 data.AddRecord(plainText);
1847 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB,
1848 .visibility = Visibility::VISIBILITY_ALL };
1849 std::string key;
1850 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
1851 ASSERT_EQ(status, E_OK);
1852
1853 QueryOption queryOption = { .key = key, .intention = UD_INTENTION_DATA_HUB };
1854 std::vector<UnifiedData> dataSet;
1855 status = UdmfClient::GetInstance().GetBatchData(queryOption, dataSet);
1856 std::shared_ptr<UnifiedRecord> record = dataSet[0].GetRecordAt(0);
1857 ASSERT_NE(record, nullptr);
1858 auto type = record->GetType();
1859 ASSERT_EQ(type, UDType::PLAIN_TEXT);
1860 auto plainText2 = static_cast<PlainText *>(record.get());
1861 ASSERT_EQ(plainText2->GetContent(), "content");
1862 std::vector<UnifiedData> dataDelete;
1863 status = UdmfClient::GetInstance().DeleteData(queryOption, dataDelete);
1864 ASSERT_EQ(status, E_OK);
1865 ASSERT_EQ(dataDelete.size(), 1);
1866 LOG_INFO(UDMF_TEST, "OH_Udmf_GetBatchData003 end.");
1867 }
1868
1869 /**
1870 * @tc.name: OH_Udmf_GetBatchData004
1871 * @tc.desc: GetBatchData data with valid params
1872 * @tc.type: FUNC
1873 */
1874 HWTEST_F(UdmfClientTest, OH_Udmf_GetBatchData004, TestSize.Level1)
1875 {
1876 LOG_INFO(UDMF_TEST, "OH_Udmf_GetBatchData004 begin.");
1877 SetHapToken1();
1878 UnifiedData data;
1879 auto plainText = std::make_shared<PlainText>();
1880 plainText->SetContent("content");
1881 data.AddRecord(plainText);
1882 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB,
1883 .visibility = Visibility::VISIBILITY_ALL };
1884 std::string key;
1885 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
1886 ASSERT_EQ(status, E_OK);
1887
1888 SetHapToken2();
1889 QueryOption queryOption = { .key = key, .intention = UD_INTENTION_DATA_HUB };
1890 std::vector<UnifiedData> dataSet;
1891 status = UdmfClient::GetInstance().GetBatchData(queryOption, dataSet);
1892 std::shared_ptr<UnifiedRecord> record = dataSet[0].GetRecordAt(0);
1893 ASSERT_NE(record, nullptr);
1894 auto type = record->GetType();
1895 ASSERT_EQ(type, UDType::PLAIN_TEXT);
1896 auto plainText2 = static_cast<PlainText *>(record.get());
1897 ASSERT_EQ(plainText2->GetContent(), "content");
1898 SetHapToken1();
1899 std::vector<UnifiedData> dataDelete;
1900 status = UdmfClient::GetInstance().DeleteData(queryOption, dataDelete);
1901 ASSERT_EQ(status, E_OK);
1902 ASSERT_EQ(dataDelete.size(), 1);
1903 LOG_INFO(UDMF_TEST, "OH_Udmf_GetBatchData004 end.");
1904 }
1905
1906 /**
1907 * @tc.name: QueryData001
1908 * @tc.desc: Query data with invalid params
1909 * @tc.type: FUNC
1910 */
1911 HWTEST_F(UdmfClientTest, QueryData001, TestSize.Level1)
1912 {
1913 LOG_INFO(UDMF_TEST, "QueryData001 begin.");
1914 std::vector<UnifiedData> unifiedDataSet;
1915 QueryOption queryOption = {};
1916 auto status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1917 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1918
1919 queryOption = { .key = "udmf://drag/ohos.test.demo1/abcde" };
1920 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1921 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1922
1923 queryOption = { .intention = UD_INTENTION_DRAG };
1924 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1925 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1926
1927 queryOption = { .key = "udmf://DataHub/ohos.test.demo1/abcde", .intention = UD_INTENTION_DRAG };
1928 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1929 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1930
1931 queryOption = { .key = "udmf://drag/ohos.test.demo1/abcde", .intention = UD_INTENTION_DATA_HUB };
1932 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1933 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1934 LOG_INFO(UDMF_TEST, "QueryData001 end.");
1935 }
1936
1937 /**
1938 * @tc.name: QueryData002
1939 * @tc.desc: Query data with valid params
1940 * @tc.type: FUNC
1941 */
1942 HWTEST_F(UdmfClientTest, QueryData002, TestSize.Level1)
1943 {
1944 LOG_INFO(UDMF_TEST, "QueryData002 begin.");
1945
1946 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
1947 std::vector<UnifiedData> unifiedDataSet;
1948 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
1949 ASSERT_EQ(status, E_OK);
1950 unifiedDataSet.clear();
1951 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
1952 ASSERT_EQ(status, E_OK);
1953 auto originSize = unifiedDataSet.size();
1954 unifiedDataSet.clear();
1955
1956 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
1957 UnifiedData data;
1958 auto plainText = std::make_shared<PlainText>();
1959 plainText->SetContent("content1");
1960 data.AddRecord(plainText);
1961 std::string key;
1962 status = UdmfClient::GetInstance().SetData(customOption, data, key);
1963 ASSERT_EQ(status, E_OK);
1964
1965 query = { .key = key };
1966 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
1967 ASSERT_EQ(status, E_OK);
1968 auto size = static_cast<int32_t>(unifiedDataSet.size());
1969 ASSERT_EQ(size, 1);
1970 std::shared_ptr<UnifiedRecord> record2 = unifiedDataSet[0].GetRecordAt(0);
1971 ASSERT_NE(record2, nullptr);
1972 auto type = record2->GetType();
1973 ASSERT_EQ(type, UDType::PLAIN_TEXT);
1974 auto plainText2 = static_cast<PlainText *>(record2.get());
1975 ASSERT_EQ(plainText2->GetContent(), "content1");
1976
1977 UnifiedData data2;
1978 plainText = std::make_shared<PlainText>();
1979 plainText->SetContent("content2");
1980 data2.AddRecord(plainText);
1981 status = UdmfClient::GetInstance().SetData(customOption, data2, key);
1982 ASSERT_EQ(status, E_OK);
1983
1984 unifiedDataSet.clear();
1985 query = { .key = key, .intention = UD_INTENTION_DATA_HUB };
1986 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
1987 ASSERT_EQ(status, E_OK);
1988 size = static_cast<int32_t>(unifiedDataSet.size());
1989 ASSERT_EQ(size, 1);
1990 record2 = unifiedDataSet[0].GetRecordAt(0);
1991 ASSERT_NE(record2, nullptr);
1992 type = record2->GetType();
1993 ASSERT_EQ(type, UDType::PLAIN_TEXT);
1994 plainText2 = static_cast<PlainText *>(record2.get());
1995 ASSERT_EQ(plainText2->GetContent(), "content2");
1996
1997 unifiedDataSet.clear();
1998 query = { .intention = UD_INTENTION_DATA_HUB };
1999 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
2000 ASSERT_EQ(status, E_OK);
2001 ASSERT_EQ(unifiedDataSet.size(), originSize + 2);
2002
2003 LOG_INFO(UDMF_TEST, "QueryData002 end.");
2004 }
2005
2006 /**
2007 * @tc.name: DeleteData001
2008 * @tc.desc: Delete data with invalid params
2009 * @tc.type: FUNC
2010 */
2011 HWTEST_F(UdmfClientTest, DeleteData001, TestSize.Level1)
2012 {
2013 LOG_INFO(UDMF_TEST, "DeleteData001 begin.");
2014 std::vector<UnifiedData> unifiedDataSet;
2015 QueryOption queryOption = {};
2016 auto status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
2017 ASSERT_EQ(status, E_INVALID_PARAMETERS);
2018
2019 queryOption = { .key = "udmf://drag/ohos.test.demo1/abcde" };
2020 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
2021 ASSERT_EQ(status, E_INVALID_PARAMETERS);
2022
2023 queryOption = { .intention = UD_INTENTION_DRAG };
2024 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
2025 ASSERT_EQ(status, E_INVALID_PARAMETERS);
2026
2027 queryOption = { .key = "udmf://DataHub/ohos.test.demo1/abcde", .intention = UD_INTENTION_DRAG };
2028 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
2029 ASSERT_EQ(status, E_INVALID_PARAMETERS);
2030
2031 queryOption = { .key = "udmf://drag/ohos.test.demo1/abcde", .intention = UD_INTENTION_DATA_HUB };
2032 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
2033 ASSERT_EQ(status, E_INVALID_PARAMETERS);
2034 LOG_INFO(UDMF_TEST, "DeleteData001 end.");
2035 }
2036
2037 /**
2038 * @tc.name: DeleteData002
2039 * @tc.desc: Delete data with valid params
2040 * @tc.type: FUNC
2041 */
2042 HWTEST_F(UdmfClientTest, DeleteData002, TestSize.Level1)
2043 {
2044 LOG_INFO(UDMF_TEST, "DeleteData002 begin.");
2045
2046 CustomOption customOption = { .intention = UD_INTENTION_DATA_HUB };
2047 UnifiedData data;
2048 auto plainText = std::make_shared<PlainText>();
2049 plainText->SetContent("content1");
2050 data.AddRecord(plainText);
2051 std::string key;
2052 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
2053 ASSERT_EQ(status, E_OK);
2054 status = UdmfClient::GetInstance().SetData(customOption, data, key);
2055 ASSERT_EQ(status, E_OK);
2056 status = UdmfClient::GetInstance().SetData(customOption, data, key);
2057 ASSERT_EQ(status, E_OK);
2058
2059 QueryOption queryOption = { .key = key };
2060 SetHapToken2();
2061
2062 std::vector<UnifiedData> unifiedDataSet;
2063 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
2064 ASSERT_EQ(status, E_OK);
2065 ASSERT_EQ(0, unifiedDataSet.size());
2066
2067 SetHapToken1();
2068 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
2069 ASSERT_EQ(status, E_OK);
2070 ASSERT_EQ(1, unifiedDataSet.size());
2071
2072 unifiedDataSet.clear();
2073 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
2074 ASSERT_TRUE(unifiedDataSet.empty());
2075
2076 queryOption = { .intention = UD_INTENTION_DATA_HUB };
2077 unifiedDataSet.clear();
2078 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
2079 ASSERT_TRUE(!unifiedDataSet.empty());
2080
2081 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
2082 ASSERT_EQ(status, E_OK);
2083
2084 unifiedDataSet.clear();
2085 queryOption = { .key = key };
2086 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
2087 ASSERT_TRUE(unifiedDataSet.empty());
2088 LOG_INFO(UDMF_TEST, "DeleteData002 end.");
2089 }
2090
2091 /**
2092 * @tc.name: SetData022
2093 * @tc.desc: Set two over 2MB record of data with valid params and get data
2094 * @tc.type: FUNC
2095 */
2096 HWTEST_F(UdmfClientTest, SetData022, TestSize.Level1)
2097 {
2098 LOG_INFO(UDMF_TEST, "SetData022 begin.");
2099
2100 CustomOption customOption = { .intention = Intention::UD_INTENTION_DRAG };
2101 UnifiedData inputData;
2102 std::string key;
2103 UDDetails details;
2104 std::string value;
2105 int64_t maxSize = 512 * 1024;
2106 for (int64_t i = 0; i < maxSize; ++i) {
2107 value += "11";
2108 }
2109 details.insert({ value, value });
2110 details.insert({ "udmf_key", "udmf_value" });
2111 auto text = std::make_shared<Text>();
2112 text->SetDetails(details);
2113 for (int i = 0; i < 2; ++i) {
2114 inputData.AddRecord(text);
2115 }
2116 UnifiedDataHelper::SetRootPath("/data/udmf_test/");
2117 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
2118 ASSERT_EQ(status, E_OK);
2119
2120 QueryOption queryOption = { .key = key };
2121 UnifiedData outputData;
2122 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
2123 ASSERT_EQ(status, E_OK);
2124 UnifiedDataHelper::SetRootPath("");
2125
2126 LOG_INFO(UDMF_TEST, "SetData022 end.");
2127 }
2128
2129 /**
2130 * @tc.name: SetData023
2131 * @tc.desc: Set 200MB record of data with valid params and get data
2132 * @tc.type: FUNC
2133 */
2134 HWTEST_F(UdmfClientTest, SetData023, TestSize.Level1)
2135 {
2136 LOG_INFO(UDMF_TEST, "SetData023 begin.");
2137
2138 CustomOption customOption = { .intention = Intention::UD_INTENTION_DRAG };
2139 UnifiedData inputData;
2140 std::string key;
2141 UDDetails details;
2142 std::string value;
2143 int64_t maxSize = 512 * 1024;
2144 for (int64_t i = 0; i < maxSize; ++i) {
2145 value += "11";
2146 }
2147 details.insert({ value, value });
2148 Text text;
2149 text.SetDetails(details);
2150 for (int64_t i = 0; i < 100; ++i) {
2151 auto record = std::make_shared<Text>();
2152 inputData.AddRecord(record);
2153 }
2154 auto records = inputData.GetRecords();
2155 LOG_INFO(UDMF_TEST, "SetData023 inputData.size() = %{public}zu", records.size());
2156 UnifiedDataHelper::SetRootPath("/data/udmf_test/");
2157 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
2158 ASSERT_EQ(status, E_OK);
2159
2160 QueryOption queryOption = { .key = key };
2161 UnifiedData outputData;
2162 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
2163 ASSERT_EQ(status, E_OK);
2164 UnifiedDataHelper::SetRootPath("");
2165
2166 LOG_INFO(UDMF_TEST, "SetData023 end.");
2167 }
2168
2169 /**
2170 * @tc.name: SetData024
2171 * @tc.desc: Set over 200MB record of data with valid params and get data
2172 * @tc.type: FUNC
2173 */
2174 HWTEST_F(UdmfClientTest, SetData024, TestSize.Level1)
2175 {
2176 LOG_INFO(UDMF_TEST, "SetData024 begin.");
2177
2178 CustomOption customOption = { .intention = Intention::UD_INTENTION_DRAG };
2179 UnifiedData inputData;
2180 std::string key;
2181 UDDetails details;
2182 std::string value;
2183 int64_t maxSize = 512 * 1024;
2184 for (int64_t i = 0; i < maxSize; ++i) {
2185 value += "11";
2186 }
2187 details.insert({ value, value });
2188 auto text = std::make_shared<Text>();
2189 text->SetDetails(details);
2190 for (int64_t i = 0; i < 101; ++i) {
2191 inputData.AddRecord(text);
2192 }
2193 auto records = inputData.GetRecords();
2194 LOG_INFO(UDMF_TEST, "SetData024 inputData.size() = %{public}zu", records.size());
2195
2196 UnifiedDataHelper::SetRootPath("/data/udmf_test/");
2197 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
2198 ASSERT_EQ(status, E_INVALID_PARAMETERS);
2199 UnifiedDataHelper::SetRootPath("");
2200
2201 LOG_INFO(UDMF_TEST, "SetData024 end.");
2202 }
2203
2204 /**
2205 * @tc.name: SetData025
2206 * @tc.desc: Set PixelMap record with valid params and get data
2207 * @tc.type: FUNC
2208 */
2209 HWTEST_F(UdmfClientTest, SetData025, TestSize.Level1)
2210 {
2211 LOG_INFO(UDMF_TEST, "SetData025 begin.");
2212
2213 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2214 UnifiedData data1;
2215 std::string key;
2216 auto systemDefinedPixelMap1 = std::make_shared<SystemDefinedPixelMap>();
2217 UDDetails details1;
2218 details1.insert({ "udmf_key", "udmf_value" });
2219 systemDefinedPixelMap1->SetDetails(details1);
2220 std::vector<uint8_t> rawData1 = { 1, 2, 3, 4, 5 };
2221
2222 systemDefinedPixelMap1->SetRawData(rawData1);
2223 data1.AddRecord(systemDefinedPixelMap1);
2224 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
2225 ASSERT_EQ(status, E_OK);
2226
2227 QueryOption option2 = { .key = key };
2228 AddPrivilege(option2);
2229 SetHapToken2();
2230 UnifiedData data2;
2231 status = UdmfClient::GetInstance().GetData(option2, data2);
2232 ASSERT_EQ(status, E_OK);
2233
2234 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
2235 ASSERT_NE(record2, nullptr);
2236 auto type = record2->GetType();
2237 ASSERT_EQ(type, UDType::SYSTEM_DEFINED_PIXEL_MAP);
2238
2239 auto systemDefinedRecord2 = static_cast<SystemDefinedRecord *>(record2.get());
2240 ASSERT_NE(systemDefinedRecord2, nullptr);
2241 CompareDetails(systemDefinedRecord2->GetDetails());
2242
2243 auto systemDefinedPixelMap2 = static_cast<SystemDefinedPixelMap *>(record2.get());
2244 ASSERT_NE(systemDefinedPixelMap2, nullptr);
2245 auto rawData2 = systemDefinedPixelMap2->GetRawData();
2246 EXPECT_EQ(rawData1.size(), rawData2.size());
2247 for (uint32_t i = 0; i < rawData1.size(); ++i) {
2248 EXPECT_EQ(rawData1[i], rawData2[i]);
2249 }
2250
2251 LOG_INFO(UDMF_TEST, "SetData025 end.");
2252 }
2253
2254 /**
2255 * @tc.name: SetData026
2256 * @tc.desc: Set more record with valid params and get data
2257 * @tc.type: FUNC
2258 */
2259 HWTEST_F(UdmfClientTest, SetData026, TestSize.Level1)
2260 {
2261 LOG_INFO(UDMF_TEST, "SetData026 begin.");
2262
2263 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2264 UnifiedData data1;
2265 std::string key;
2266 auto systemDefinedPixelMap1 = std::make_shared<SystemDefinedPixelMap>();
2267 UDDetails details1;
2268 details1.insert({ "udmf_key", "udmf_value" });
2269 systemDefinedPixelMap1->SetDetails(details1);
2270 std::vector<uint8_t> rawData1 = { 1, 2, 3, 4, 5 };
2271
2272 systemDefinedPixelMap1->SetRawData(rawData1);
2273 std::shared_ptr<UnifiedRecord> record2 = std::make_shared<PlainText>(UDType::PLAIN_TEXT, "this is a content");
2274 data1.AddRecord(systemDefinedPixelMap1);
2275 data1.AddRecord(record2);
2276 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
2277 ASSERT_EQ(status, E_OK);
2278
2279 QueryOption option2 = { .key = key };
2280 AddPrivilege(option2);
2281 SetHapToken2();
2282 UnifiedData data2;
2283 status = UdmfClient::GetInstance().GetData(option2, data2);
2284 ASSERT_EQ(status, E_OK);
2285
2286 std::shared_ptr<UnifiedRecord> record3 = data2.GetRecordAt(0);
2287 ASSERT_NE(record3, nullptr);
2288 auto type = record3->GetType();
2289 ASSERT_EQ(type, UDType::SYSTEM_DEFINED_PIXEL_MAP);
2290
2291 auto systemDefinedRecord2 = static_cast<SystemDefinedRecord *>(record3.get());
2292 ASSERT_NE(systemDefinedRecord2, nullptr);
2293 CompareDetails(systemDefinedRecord2->GetDetails());
2294
2295 auto systemDefinedPixelMap2 = static_cast<SystemDefinedPixelMap *>(record3.get());
2296 ASSERT_NE(systemDefinedPixelMap2, nullptr);
2297 auto rawData2 = systemDefinedPixelMap2->GetRawData();
2298 EXPECT_EQ(rawData1.size(), rawData2.size());
2299 for (uint32_t i = 0; i < rawData1.size(); ++i) {
2300 EXPECT_EQ(rawData1[i], rawData2[i]);
2301 }
2302
2303 std::shared_ptr<UnifiedRecord> record4 = data2.GetRecordAt(1);
2304 auto plainText = static_cast<PlainText *>(record4.get());
2305 ASSERT_EQ(UDType::PLAIN_TEXT, plainText->GetType());
2306 ASSERT_EQ("this is a content", plainText->GetContent());
2307
2308 LOG_INFO(UDMF_TEST, "SetData026 end.");
2309 }
2310
2311 /**
2312 * @tc.name: SetData027
2313 * @tc.desc: Set Html record value is null str and get uris data
2314 * @tc.type: FUNC
2315 */
2316 HWTEST_F(UdmfClientTest, SetData027, TestSize.Level1)
2317 {
2318 LOG_INFO(UDMF_TEST, "SetData027 begin.");
2319
2320 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2321 UnifiedData data;
2322 std::string key;
2323 std::string html = "";
2324 auto obj = std::make_shared<Object>();
2325 obj->value_["uniformDataType"] = "general.html";
2326 obj->value_["htmlContent"] = html;
2327 obj->value_["plainContent"] = "htmlPlainContent";
2328 auto obj2 = std::make_shared<Object>();
2329 obj2->value_["detail1"] = "detail1";
2330 obj2->value_["detail2"] = "detail2";
2331 obj->value_["details"] = obj2;
2332 auto htmlRecord = std::make_shared<Html>(UDType::HTML, obj);
2333 data.AddRecord(htmlRecord);
2334 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
2335 ASSERT_EQ(status, E_OK);
2336
2337 QueryOption option2 = { .key = key };
2338 AddPrivilege1(option2);
2339 SetHapToken1();
2340 UnifiedData readData;
2341 status = UdmfClient::GetInstance().GetData(option2, readData);
2342 ASSERT_EQ(status, E_OK);
2343
2344 std::shared_ptr<UnifiedRecord> readRecord = readData.GetRecordAt(0);
2345 ASSERT_NE(readRecord, nullptr);
2346 auto readHtmlRecord = std::static_pointer_cast<Html>(readRecord);
2347 EXPECT_EQ(readHtmlRecord->GetHtmlContent(), html);
2348 auto uris = readRecord->GetUris();
2349 EXPECT_EQ(uris.size(), 0);
2350
2351 LOG_INFO(UDMF_TEST, "SetData027 end.");
2352 }
2353
2354 /**
2355 * @tc.name: SetData028
2356 * @tc.desc: Set Html record include invalid value and get uris data
2357 * @tc.type: FUNC
2358 */
2359 HWTEST_F(UdmfClientTest, SetData028, TestSize.Level1)
2360 {
2361 LOG_INFO(UDMF_TEST, "SetData028 begin.");
2362
2363 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2364 UnifiedData data;
2365 std::string key;
2366 std::string html = "<img data-ohos='clipboard' src=>"
2367 "<img data-ohos='clipboard' src='https://data/storage/el2/base/haps/102.png'>"
2368 "<img data-ohos='clipboard' src='file://data/storage/el2/base/haps/103.png'>"
2369 "<img data-ohos='clipboard' src='file://data/storage/el2/base/haps/104.png'>";
2370 auto obj = std::make_shared<Object>();
2371 obj->value_["uniformDataType"] = "general.html";
2372 obj->value_["htmlContent"] = html;
2373 obj->value_["plainContent"] = "htmlPlainContent";
2374 auto obj2 = std::make_shared<Object>();
2375 obj2->value_["detail1"] = "detail1";
2376 obj2->value_["detail2"] = "detail2";
2377 obj->value_["details"] = obj2;
2378 auto htmlRecord = std::make_shared<Html>(UDType::HTML, obj);
2379 data.AddRecord(htmlRecord);
2380 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
2381 ASSERT_EQ(status, E_OK);
2382
2383 QueryOption option2 = { .key = key };
2384 AddPrivilege1(option2);
2385 SetHapToken1();
2386 UnifiedData readData;
2387 status = UdmfClient::GetInstance().GetData(option2, readData);
2388 ASSERT_EQ(status, E_OK);
2389
2390 std::shared_ptr<UnifiedRecord> readRecord = readData.GetRecordAt(0);
2391 ASSERT_NE(readRecord, nullptr);
2392 auto readHtmlRecord = std::static_pointer_cast<Html>(readRecord);
2393 EXPECT_EQ(readHtmlRecord->GetHtmlContent(), html);
2394 auto uris = readRecord->GetUris();
2395 EXPECT_EQ(uris.size(), 0);
2396
2397 LOG_INFO(UDMF_TEST, "SetData028 end.");
2398 }
2399
2400 /**
2401 * @tc.name: SetData029
2402 * @tc.desc: Set Html record include valid value and get uris data
2403 * @tc.type: FUNC
2404 */
2405 HWTEST_F(UdmfClientTest, SetData029, TestSize.Level1)
2406 {
2407 LOG_INFO(UDMF_TEST, "SetData029 begin.");
2408
2409 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2410 UnifiedData data;
2411 std::string key;
2412 std::string html = "<img data-ohos='clipboard' src='file:///data/storage/el2/base/haps/101.png'>"
2413 "<img data-ohos='clipboard' src=\"file:///data/storage/el2/base/haps/102.png\">";
2414 auto obj = std::make_shared<Object>();
2415 obj->value_["uniformDataType"] = "general.html";
2416 obj->value_["htmlContent"] = html;
2417 obj->value_["plainContent"] = "htmlPlainContent";
2418 auto obj2 = std::make_shared<Object>();
2419 obj2->value_["detail1"] = "detail1";
2420 obj2->value_["detail2"] = "detail2";
2421 obj->value_["details"] = obj2;
2422 auto htmlRecord = std::make_shared<Html>(UDType::HTML, obj);
2423 data.AddRecord(htmlRecord);
2424 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
2425 ASSERT_EQ(status, E_OK);
2426
2427 QueryOption option2 = { .key = key };
2428 AddPrivilege1(option2);
2429 SetHapToken1();
2430 UnifiedData readData;
2431 status = UdmfClient::GetInstance().GetData(option2, readData);
2432 ASSERT_EQ(status, E_OK);
2433 std::string tmpUri1 = "file://ohos.test.demo1/data/storage/el2/base/haps/101.png";
2434 std::string tmpUri2 = "file://ohos.test.demo1/data/storage/el2/base/haps/102.png";
2435 AppFileService::ModuleFileUri::FileUri fileUri1(tmpUri1);
2436 AppFileService::ModuleFileUri::FileUri fileUri2(tmpUri2);
2437 std::string readHtml = "<img data-ohos='clipboard' src='";
2438 readHtml += FILE_SCHEME_PREFIX + fileUri1.GetRealPath() + "'><img data-ohos='clipboard' src=\"";
2439 readHtml += FILE_SCHEME_PREFIX + fileUri2.GetRealPath() + "\">";
2440 std::shared_ptr<UnifiedRecord> readRecord = readData.GetRecordAt(0);
2441 ASSERT_NE(readRecord, nullptr);
2442 auto readHtmlRecord = std::static_pointer_cast<Html>(readRecord);
2443 EXPECT_EQ(readHtmlRecord->GetHtmlContent(), readHtml);
2444 auto uris = readRecord->GetUris();
2445 EXPECT_EQ(uris.size(), 2);
2446
2447 LOG_INFO(UDMF_TEST, "SetData029 end.");
2448 }
2449
2450 /**
2451 * @tc.name: SetData030
2452 * @tc.desc: Set Html record include valid value and get uris data
2453 * @tc.type: FUNC
2454 */
2455 HWTEST_F(UdmfClientTest, SetData030, TestSize.Level1)
2456 {
2457 LOG_INFO(UDMF_TEST, "SetData030 begin.");
2458
2459 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2460 UnifiedData data;
2461 std::string key;
2462 std::string html = "<img data-ohos='clipboard' src='file:///data/storage/el2/base/haps/101.png'>"
2463 "<img data-ohos='clipboard' src='https://data/storage/el2/base/haps/102.png'>"
2464 "<img data-ohos='clipboard' src='file://data/storage/el2/base/haps/103.png'>";
2465 std::string uriSrc = "file:///data/storage/el2/base/haps/101.png";
2466 auto obj = std::make_shared<Object>();
2467 obj->value_["uniformDataType"] = "general.html";
2468 obj->value_["htmlContent"] = html;
2469 obj->value_["plainContent"] = "htmlPlainContent";
2470 auto obj2 = std::make_shared<Object>();
2471 obj2->value_["detail1"] = "detail1";
2472 obj2->value_["detail2"] = "detail2";
2473 obj->value_["details"] = obj2;
2474 auto htmlRecord = std::make_shared<Html>(UDType::HTML, obj);
2475 data.AddRecord(htmlRecord);
2476 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
2477 ASSERT_EQ(status, E_OK);
2478
2479 QueryOption option2 = { .key = key };
2480 AddPrivilege1(option2);
2481 SetHapToken1();
2482 UnifiedData readData;
2483 status = UdmfClient::GetInstance().GetData(option2, readData);
2484 ASSERT_EQ(status, E_OK);
2485 std::string tmpUri1 = "file://ohos.test.demo1/data/storage/el2/base/haps/101.png";
2486 AppFileService::ModuleFileUri::FileUri fileUri1(tmpUri1);
2487 std::string readHtml = "<img data-ohos='clipboard' src='";
2488 readHtml += FILE_SCHEME_PREFIX + fileUri1.GetRealPath() + "'>";
2489 readHtml += "<img data-ohos='clipboard' src='https://data/storage/el2/base/haps/102.png'>"
2490 "<img data-ohos='clipboard' src='file://data/storage/el2/base/haps/103.png'>";
2491 std::shared_ptr<UnifiedRecord> readRecord = readData.GetRecordAt(0);
2492 ASSERT_NE(readRecord, nullptr);
2493 auto readHtmlRecord = std::static_pointer_cast<Html>(readRecord);
2494 EXPECT_EQ(readHtmlRecord->GetHtmlContent(), readHtml);
2495 auto uris = readRecord->GetUris();
2496 EXPECT_EQ(uris.size(), 1);
2497 EXPECT_EQ(uris[0].oriUri, uriSrc);
2498 EXPECT_TRUE(uris[0].dfsUri.empty());
2499
2500 LOG_INFO(UDMF_TEST, "SetData030 end.");
2501 }
2502
2503 /**
2504 * @tc.name: SetData031
2505 * @tc.desc: Set Html entry is null str and get uris data
2506 * @tc.type: FUNC
2507 */
2508 HWTEST_F(UdmfClientTest, SetData031, TestSize.Level1)
2509 {
2510 LOG_INFO(UDMF_TEST, "SetData031 begin.");
2511
2512 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2513 UnifiedData data;
2514 std::string key;
2515 std::shared_ptr<Object> obj = std::make_shared<Object>();
2516 obj->value_[UNIFORM_DATA_TYPE] = "general.file-uri";
2517 obj->value_[FILE_URI_PARAM] = "http://demo.com";
2518 obj->value_[FILE_TYPE] = "abcdefg";
2519 auto record = std::make_shared<UnifiedRecord>(FILE_URI, obj);
2520 std::string html = "";
2521 auto htmlRecord = Html(html, "abstract");
2522 htmlRecord.InitObject();
2523 record->AddEntry(htmlRecord.GetUtdId(), htmlRecord.GetOriginValue());
2524 data.AddRecord(record);
2525 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
2526 ASSERT_EQ(status, E_OK);
2527
2528 QueryOption option2 = { .key = key };
2529 AddPrivilege1(option2);
2530 SetHapToken1();
2531 UnifiedData readData;
2532 status = UdmfClient::GetInstance().GetData(option2, readData);
2533 ASSERT_EQ(status, E_OK);
2534
2535 std::shared_ptr<UnifiedRecord> readRecord = readData.GetRecordAt(0);
2536 ASSERT_NE(readRecord, nullptr);
2537 auto entryValue = readRecord->GetEntry(UtdUtils::GetUtdIdFromUtdEnum(UDType::HTML));
2538 auto object = std::get<std::shared_ptr<Object>>(entryValue);
2539 ASSERT_NE(object, nullptr);
2540 auto iter = object->value_.find(HTML_CONTENT);
2541 ASSERT_TRUE(iter != object->value_.end());
2542 EXPECT_TRUE(std::holds_alternative<std::string>(iter->second));
2543 auto content = std::get<std::string>(iter->second);
2544 EXPECT_EQ(content, html);
2545 auto uris = readRecord->GetUris();
2546 EXPECT_EQ(uris.size(), 0);
2547
2548 LOG_INFO(UDMF_TEST, "SetData031 end.");
2549 }
2550
2551 /**
2552 * @tc.name: SetData032
2553 * @tc.desc: Set Html entry include invalid value and get uris data
2554 * @tc.type: FUNC
2555 */
2556 HWTEST_F(UdmfClientTest, SetData032, TestSize.Level1)
2557 {
2558 LOG_INFO(UDMF_TEST, "SetData032 begin.");
2559
2560 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2561 UnifiedData data;
2562 std::string key;
2563 std::shared_ptr<Object> obj = std::make_shared<Object>();
2564 obj->value_[UNIFORM_DATA_TYPE] = "general.file-uri";
2565 obj->value_[FILE_URI_PARAM] = "http://demo.com";
2566 obj->value_[FILE_TYPE] = "abcdefg";
2567 auto record = std::make_shared<UnifiedRecord>(FILE_URI, obj);
2568 std::string html = "<img data-ohos='clipboard' src=>"
2569 "<img data-ohos='clipboard' src='https://data/storage/el2/base/haps/102.png'>"
2570 "<img data-ohos='clipboard' src='file://data/storage/el2/base/haps/103.png'>"
2571 "<img data-ohos='clipboard' src='file://data/storage/el2/base/haps/104.png'>";
2572 auto htmlRecord = Html(html, "abstract");
2573 htmlRecord.InitObject();
2574 record->AddEntry(htmlRecord.GetUtdId(), htmlRecord.GetOriginValue());
2575 data.AddRecord(record);
2576 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
2577 ASSERT_EQ(status, E_OK);
2578
2579 QueryOption option2 = { .key = key };
2580 AddPrivilege1(option2);
2581 SetHapToken1();
2582 UnifiedData readData;
2583 status = UdmfClient::GetInstance().GetData(option2, readData);
2584 ASSERT_EQ(status, E_OK);
2585
2586 std::shared_ptr<UnifiedRecord> readRecord = readData.GetRecordAt(0);
2587 ASSERT_NE(readRecord, nullptr);
2588 auto entryValue = readRecord->GetEntry(UtdUtils::GetUtdIdFromUtdEnum(UDType::HTML));
2589 auto object = std::get<std::shared_ptr<Object>>(entryValue);
2590 ASSERT_NE(object, nullptr);
2591 auto iter = object->value_.find(HTML_CONTENT);
2592 ASSERT_TRUE(iter != object->value_.end());
2593 EXPECT_TRUE(std::holds_alternative<std::string>(iter->second));
2594 auto content = std::get<std::string>(iter->second);
2595 EXPECT_EQ(content, html);
2596 auto uris = readRecord->GetUris();
2597 EXPECT_EQ(uris.size(), 0);
2598
2599 LOG_INFO(UDMF_TEST, "SetData032 end.");
2600 }
2601
2602 /**
2603 * @tc.name: SetData033
2604 * @tc.desc: Set Html entry include valid value and get uris data
2605 * @tc.type: FUNC
2606 */
2607 HWTEST_F(UdmfClientTest, SetData033, TestSize.Level1)
2608 {
2609 LOG_INFO(UDMF_TEST, "SetData033 begin.");
2610
2611 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2612 UnifiedData data;
2613 std::string key;
2614 std::shared_ptr<Object> obj = std::make_shared<Object>();
2615 obj->value_[UNIFORM_DATA_TYPE] = "general.file-uri";
2616 obj->value_[FILE_URI_PARAM] = "http://demo.com";
2617 auto record = std::make_shared<UnifiedRecord>(FILE_URI, obj);
2618 std::string html = "<img data-ohos='clipboard' src='file://data/storage/el2/base/haps/101.png'>"
2619 "<img data-ohos='clipboard' src='https://data/storage/el2/base/haps/102.png'>"
2620 "<img data-ohos='clipboard' src='file:///data/storage/el2/base/haps/103.png'>";
2621 std::string uriSrc = "file:///data/storage/el2/base/haps/103.png";
2622 auto htmlRecord = Html(html, "abstract");
2623 htmlRecord.InitObject();
2624 record->AddEntry(htmlRecord.GetUtdId(), htmlRecord.GetOriginValue());
2625 data.AddRecord(record);
2626 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
2627 ASSERT_EQ(status, E_OK);
2628 QueryOption option2 = { .key = key };
2629 AddPrivilege1(option2);
2630 SetHapToken1();
2631 UnifiedData readData;
2632 status = UdmfClient::GetInstance().GetData(option2, readData);
2633 ASSERT_EQ(status, E_OK);
2634 std::string tmpUri1 = "file://ohos.test.demo1/data/storage/el2/base/haps/103.png";
2635 AppFileService::ModuleFileUri::FileUri fileUri1(tmpUri1);
2636 std::string readHtml = "<img data-ohos='clipboard' src='file://data/storage/el2/base/haps/101.png'>"
2637 "<img data-ohos='clipboard' src='https://data/storage/el2/base/haps/102.png'>"
2638 "<img data-ohos='clipboard' src='";
2639 readHtml += FILE_SCHEME_PREFIX + fileUri1.GetRealPath() + "'>";
2640 std::shared_ptr<UnifiedRecord> readRecord = readData.GetRecordAt(0);
2641 ASSERT_NE(readRecord, nullptr);
2642 auto entryValue = readRecord->GetEntry(UtdUtils::GetUtdIdFromUtdEnum(UDType::HTML));
2643 auto object = std::get<std::shared_ptr<Object>>(entryValue);
2644 ASSERT_NE(object, nullptr);
2645 auto iter = object->value_.find(HTML_CONTENT);
2646 ASSERT_TRUE(iter != object->value_.end());
2647 EXPECT_TRUE(std::holds_alternative<std::string>(iter->second));
2648 auto content = std::get<std::string>(iter->second);
2649 EXPECT_EQ(content, readHtml);
2650 auto uris = readRecord->GetUris();
2651 EXPECT_EQ(uris.size(), 1);
2652 EXPECT_EQ(uris[0].oriUri, uriSrc);
2653 EXPECT_TRUE(uris[0].dfsUri.empty());
2654
2655 LOG_INFO(UDMF_TEST, "SetData033 end.");
2656 }
2657
2658 /**
2659 * @tc.name: SetData034
2660 * @tc.desc: test html record process
2661 * @tc.type: FUNC
2662 */
2663 HWTEST_F(UdmfClientTest, SetData034, TestSize.Level1)
2664 {
2665 LOG_INFO(UDMF_TEST, "SetData034 begin.");
2666
2667 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2668 UnifiedData data1;
2669 std::shared_ptr<UnifiedRecord> record = std::make_shared<UnifiedRecord>();
2670 data1.AddRecord(record);
2671 std::string key;
2672 UnifiedHtmlRecordProcess::RebuildHtmlRecord(data1);
2673 UnifiedHtmlRecordProcess::GetUriFromHtmlRecord(data1);
2674 UnifiedData data;
2675 auto plainText = std::make_shared<PlainText>();
2676 plainText->SetContent("plainContent");
2677 data.AddRecord(plainText);
2678 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
2679 ASSERT_EQ(status, E_OK);
2680 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<PlainText>(UDType::PLAIN_TEXT, "this is a content");
2681 record1->ClearUris();
2682 data.AddRecord(record1);
2683 auto file = std::make_shared<File>();
2684 file->SetRemoteUri("remoteUri");
2685 UDDetails details;
2686 details.insert({ "udmf_key", "udmf_value" });
2687 file->SetDetails(details);
2688 data.AddRecord(file);
2689 UnifiedHtmlRecordProcess::RebuildHtmlRecord(data);
2690
2691 QueryOption option2 = { .key = key };
2692 AddPrivilege1(option2);
2693 SetHapToken1();
2694 UnifiedData readData;
2695 status = UdmfClient::GetInstance().GetData(option2, readData);
2696 ASSERT_EQ(status, E_OK);
2697
2698 LOG_INFO(UDMF_TEST, "SetData034 end.");
2699 }
2700
2701 /**
2702 * @tc.name: SetData035
2703 * @tc.desc: test html record process
2704 * @tc.type: FUNC
2705 */
2706 HWTEST_F(UdmfClientTest, SetData035, TestSize.Level1)
2707 {
2708 LOG_INFO(UDMF_TEST, "SetData035 begin.");
2709
2710 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2711 UnifiedData data;
2712 auto text = std::make_shared<Text>();
2713 data.AddRecord(text);
2714 auto plainText = std::make_shared<PlainText>();
2715 plainText->SetContent("plainContent");
2716 data.AddRecord(plainText);
2717 auto html = std::make_shared<Html>();
2718 html->SetPlainContent("htmlContent");
2719 data.AddRecord(html);
2720 std::string key;
2721 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
2722 ASSERT_EQ(status, E_OK);
2723
2724 UnifiedData data1;
2725 std::shared_ptr<Object> obj = std::make_shared<Object>();
2726 obj->value_[PLAIN_CONTENT] = "http://demo.com";
2727 obj->value_[HTML_CONTENT] = 10;
2728 plainText->AddEntry("general.html", obj);
2729 data1.AddRecord(plainText);
2730 UnifiedHtmlRecordProcess::GetUriFromHtmlRecord(data1);
2731 UnifiedHtmlRecordProcess::RebuildHtmlRecord(data1);
2732 UnifiedData data2;
2733 text->AddEntry("general.html", "");
2734 data2.AddRecord(text);
2735 UnifiedHtmlRecordProcess::GetUriFromHtmlRecord(data2);
2736 UnifiedHtmlRecordProcess::RebuildHtmlRecord(data2);
2737 QueryOption option2 = { .key = key };
2738 AddPrivilege1(option2);
2739 SetHapToken1();
2740 UnifiedData readData;
2741 status = UdmfClient::GetInstance().GetData(option2, readData);
2742 ASSERT_EQ(status, E_OK);
2743
2744 LOG_INFO(UDMF_TEST, "SetData035 end.");
2745 }
2746
2747 /**
2748 * @tc.name: GetSummary003
2749 * @tc.desc: Get summary data
2750 * @tc.type: FUNC
2751 */
2752 HWTEST_F(UdmfClientTest, GetSummary003, TestSize.Level1)
2753 {
2754 LOG_INFO(UDMF_TEST, "GetSummary003 begin.");
2755
2756 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2757 UnifiedData data;
2758 std::string key;
2759
2760 UDDetails details;
2761 details.insert({ "udmf_key", "udmf_value" });
2762 std::string value;
2763 int64_t maxSize = 512 * 1024;
2764 for (int64_t i = 0; i < maxSize; ++i) {
2765 value += "11";
2766 }
2767 details.insert({ value, value });
2768
2769 auto text = std::make_shared<Text>();
2770 text->SetDetails(details);
2771 data.AddRecord(text);
2772
2773 auto plainText = std::make_shared<PlainText>();
2774 plainText->SetDetails(details);
2775 plainText->SetContent("content");
2776 plainText->SetAbstract("abstract");
2777 data.AddRecord(plainText);
2778
2779 UnifiedDataHelper::SetRootPath("/data/udmf_test/");
2780 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
2781 ASSERT_EQ(status, E_OK);
2782 UnifiedDataHelper::SetRootPath("");
2783
2784 QueryOption option2 = { .key = key };
2785 Summary summary;
2786 status = UdmfClient::GetInstance().GetSummary(option2, summary);
2787
2788 auto size = text->GetSize();
2789 size += plainText->GetSize();
2790
2791 ASSERT_EQ(status, E_OK);
2792 ASSERT_EQ(summary.totalSize, size);
2793 ASSERT_EQ(summary.summary["general.text"], text->GetSize());
2794 ASSERT_EQ(summary.summary["general.plain-text"], plainText->GetSize());
2795
2796 LOG_INFO(UDMF_TEST, "GetSummary003 end.");
2797 }
2798
2799 /**
2800 * @tc.name: IsRemoteData
2801 * @tc.desc: is remote data, result false: not remote data, true: remote data.
2802 * @tc.type: FUNC
2803 */
2804 HWTEST_F(UdmfClientTest, IsRemoteData001, TestSize.Level1)
2805 {
2806 LOG_INFO(UDMF_TEST, "IsRemoteData001 begin.");
2807
2808 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2809 UnifiedData data;
2810 std::string key;
2811
2812 UDDetails details;
2813 details.insert({ "udmf_key", "udmf_value" });
2814
2815 auto text = std::make_shared<Text>();
2816 text->SetDetails(details);
2817 data.AddRecord(text);
2818
2819 auto plainText = std::make_shared<PlainText>();
2820 plainText->SetDetails(details);
2821 plainText->SetContent("content");
2822 plainText->SetAbstract("abstract");
2823 data.AddRecord(plainText);
2824
2825 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
2826 ASSERT_EQ(status, E_OK);
2827
2828 QueryOption option2 = { .key = key };
2829 bool result = true;
2830 status = UdmfClient::GetInstance().IsRemoteData(option2, result);
2831
2832 ASSERT_EQ(status, E_OK);
2833 ASSERT_EQ(result, false);
2834
2835 LOG_INFO(UDMF_TEST, "IsRemoteData001 end.");
2836 }
2837
2838 /**
2839 * @tc.name: GetTypesLabels001
2840 * @tc.desc: test GetTypesLabels
2841 * @tc.type: FUNC
2842 */
2843 HWTEST_F(UdmfClientTest, GetTypesLabels001, TestSize.Level1)
2844 {
2845 LOG_INFO(UDMF_TEST, "GetTypesLabels001 begin.");
2846 UnifiedData data;
2847 UDDetails details;
2848 details.insert({ "udmf_key", "udmf_value" });
2849 auto text = std::make_shared<Text>();
2850 text->SetDetails(details);
2851 auto plainText = std::make_shared<PlainText>();
2852 plainText->SetDetails(details);
2853 std::vector<std::shared_ptr<UnifiedRecord>> records = {text, plainText};
2854 data.AddRecords(records);
2855
2856 std::vector<std::string> types = {"general.text", "general.plain-text"};
2857 ASSERT_EQ(data.GetTypesLabels(), types);
2858 ASSERT_EQ(data.HasType("general.text"), true);
2859 ASSERT_EQ(data.HasType("general.plain-text"), true);
2860 ASSERT_EQ(data.HasType("general.html"), false);
2861 }
2862
2863 /**
2864 * @tc.name: QueryUDSData001
2865 * @tc.desc: QueryUDSData001
2866 * @tc.type: FUNC
2867 */
2868 HWTEST_F(UdmfClientTest, QueryUDSData001, TestSize.Level1)
2869 {
2870 LOG_INFO(UDMF_TEST, "QueryUDSData001 begin.");
2871
2872 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
2873 std::vector<UnifiedData> unifiedDataSet;
2874 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
2875 ASSERT_EQ(status, E_OK);
2876 unifiedDataSet.clear();
2877 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
2878 ASSERT_EQ(status, E_OK);
2879 unifiedDataSet.clear();
2880
2881 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
2882 UnifiedData data;
2883 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<PlainText>(UDType::PLAIN_TEXT, "plainTextContent");
2884 data.AddRecord(record1);
2885 std::string key;
2886 status = UdmfClient::GetInstance().SetData(customOption, data, key);
2887 ASSERT_EQ(status, E_OK);
2888
2889 query = { .key = key };
2890 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
2891 ASSERT_EQ(status, E_OK);
2892 ASSERT_EQ(unifiedDataSet.size(), 1);
2893 std::shared_ptr<UnifiedRecord> record2 = unifiedDataSet[0].GetRecordAt(0);
2894 ASSERT_NE(record2, nullptr);
2895 ASSERT_EQ(record2->GetType(), UDType::PLAIN_TEXT);
2896 ValueType value = record2->GetValue();
2897 ASSERT_NE(std::get_if<std::string>(&value), nullptr);
2898 ASSERT_EQ(std::get<std::string>(value), "plainTextContent");
2899 LOG_INFO(UDMF_TEST, "QueryUDSData001 end.");
2900 }
2901
2902 /**
2903 * @tc.name: QueryUDSData002
2904 * @tc.desc: QueryUDSData002
2905 * @tc.type: FUNC
2906 */
2907 HWTEST_F(UdmfClientTest, QueryUDSData002, TestSize.Level1)
2908 {
2909 LOG_INFO(UDMF_TEST, "QueryUDSData002 begin.");
2910
2911 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
2912 std::vector<UnifiedData> unifiedDataSet;
2913 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
2914 ASSERT_EQ(status, E_OK);
2915 unifiedDataSet.clear();
2916 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
2917 ASSERT_EQ(status, E_OK);
2918 unifiedDataSet.clear();
2919
2920 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
2921 UnifiedData data;
2922 auto obj = std::make_shared<Object>();
2923 obj->value_["uniformDataType"] = "general.plain-text";
2924 obj->value_["textContent"] = "plainTextContent";
2925 obj->value_["abstract"] = "plainTextAbstract";
2926 auto obj2 = std::make_shared<Object>();
2927 obj2->value_["detail1"] = "detail1";
2928 obj2->value_["detail2"] = "detail2";
2929 obj->value_["details"] = obj2;
2930 auto record = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
2931 data.AddRecord(record);
2932 std::string key;
2933 status = UdmfClient::GetInstance().SetData(customOption, data, key);
2934 ASSERT_EQ(status, E_OK);
2935
2936 unifiedDataSet.clear();
2937 query = { .key = key, .intention = UD_INTENTION_DATA_HUB };
2938 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
2939 ASSERT_EQ(status, E_OK);
2940 ASSERT_EQ(unifiedDataSet.size(), 1);
2941 auto record2 = unifiedDataSet[0].GetRecordAt(0);
2942 ASSERT_NE(record2, nullptr);
2943 ASSERT_EQ(record2->GetType(), UDType::PLAIN_TEXT);
2944 auto value = record2->GetValue();
2945
2946 ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&value), nullptr);
2947 obj = std::get<std::shared_ptr<Object>>(value);
2948
2949 ASSERT_NE(std::get_if<std::string>(&obj->value_["uniformDataType"]), nullptr);
2950 ASSERT_EQ(std::get<std::string>(obj->value_["uniformDataType"]), "general.plain-text");
2951 ASSERT_NE(std::get_if<std::string>(&obj->value_["textContent"]), nullptr);
2952 ASSERT_EQ(std::get<std::string>(obj->value_["textContent"]), "plainTextContent");
2953 ASSERT_NE(std::get_if<std::string>(&obj->value_["abstract"]), nullptr);
2954 ASSERT_EQ(std::get<std::string>(obj->value_["abstract"]), "plainTextAbstract");
2955
2956 ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&obj->value_["details"]), nullptr);
2957 obj2 = std::get<std::shared_ptr<Object>>(obj->value_["details"]);
2958
2959 ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail1"]), nullptr);
2960 ASSERT_EQ(std::get<std::string>(obj2->value_["detail1"]), "detail1");
2961 ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail2"]), nullptr);
2962 ASSERT_EQ(std::get<std::string>(obj2->value_["detail2"]), "detail2");
2963 LOG_INFO(UDMF_TEST, "QueryUDSData002 end.");
2964 }
2965
2966 /**
2967 * @tc.name: QueryUDSData003
2968 * @tc.desc: QueryUDSData003
2969 * @tc.type: FUNC
2970 */
2971 HWTEST_F(UdmfClientTest, QueryUDSData003, TestSize.Level1)
2972 {
2973 LOG_INFO(UDMF_TEST, "QueryUDSData003 begin.");
2974
2975 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
2976 std::vector<UnifiedData> unifiedDataSet;
2977 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
2978 ASSERT_EQ(status, E_OK);
2979 unifiedDataSet.clear();
2980 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
2981 ASSERT_EQ(status, E_OK);
2982 unifiedDataSet.clear();
2983
2984 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
2985 UnifiedData data;
2986 auto obj = std::make_shared<Object>();
2987 obj->value_["uniformDataType"] = "general.hyperlink";
2988 obj->value_["url"] = "www.xxx";
2989 obj->value_["description"] = "hyperlinkDescription";
2990 auto obj2 = std::make_shared<Object>();
2991 obj2->value_["detail1"] = "detail1";
2992 obj2->value_["detail2"] = "detail2";
2993 obj->value_["details"] = obj2;
2994 auto record = std::make_shared<Link>(UDType::HYPERLINK, obj);
2995 data.AddRecord(record);
2996 std::string key;
2997 status = UdmfClient::GetInstance().SetData(customOption, data, key);
2998 ASSERT_EQ(status, E_OK);
2999
3000 unifiedDataSet.clear();
3001 query = { .key = key, .intention = UD_INTENTION_DATA_HUB };
3002 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
3003 ASSERT_EQ(status, E_OK);
3004 ASSERT_EQ(unifiedDataSet.size(), 1);
3005 auto record2 = unifiedDataSet[0].GetRecordAt(0);
3006 ASSERT_NE(record2, nullptr);
3007 ASSERT_EQ(record2->GetType(), UDType::HYPERLINK);
3008 auto value = record2->GetValue();
3009
3010 ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&value), nullptr);
3011 obj = std::get<std::shared_ptr<Object>>(value);
3012
3013 ASSERT_NE(std::get_if<std::string>(&obj->value_["uniformDataType"]), nullptr);
3014 ASSERT_EQ(std::get<std::string>(obj->value_["uniformDataType"]), "general.hyperlink");
3015 ASSERT_NE(std::get_if<std::string>(&obj->value_["url"]), nullptr);
3016 ASSERT_EQ(std::get<std::string>(obj->value_["url"]), "www.xxx");
3017 ASSERT_NE(std::get_if<std::string>(&obj->value_["description"]), nullptr);
3018 ASSERT_EQ(std::get<std::string>(obj->value_["description"]), "hyperlinkDescription");
3019
3020 ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&obj->value_["details"]), nullptr);
3021 obj2 = std::get<std::shared_ptr<Object>>(obj->value_["details"]);
3022
3023 ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail1"]), nullptr);
3024 ASSERT_EQ(std::get<std::string>(obj2->value_["detail1"]), "detail1");
3025 ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail2"]), nullptr);
3026 ASSERT_EQ(std::get<std::string>(obj2->value_["detail2"]), "detail2");
3027 LOG_INFO(UDMF_TEST, "QueryUDSData003 end.");
3028 }
3029
3030 /**
3031 * @tc.name: QueryUDSData004
3032 * @tc.desc: QueryUDSData004
3033 * @tc.type: FUNC
3034 */
3035 HWTEST_F(UdmfClientTest, QueryUDSData004, TestSize.Level1)
3036 {
3037 LOG_INFO(UDMF_TEST, "QueryUDSData004 begin.");
3038
3039 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
3040 std::vector<UnifiedData> unifiedDataSet;
3041 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
3042 ASSERT_EQ(status, E_OK);
3043 unifiedDataSet.clear();
3044 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
3045 ASSERT_EQ(status, E_OK);
3046 unifiedDataSet.clear();
3047
3048 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
3049 UnifiedData data;
3050 auto obj = std::make_shared<Object>();
3051 obj->value_["uniformDataType"] = "general.html";
3052 obj->value_["htmlContent"] = "www.xxx";
3053 obj->value_["plainContent"] = "htmlPlainContent";
3054 auto obj2 = std::make_shared<Object>();
3055 obj2->value_["detail1"] = "detail1";
3056 obj2->value_["detail2"] = "detail2";
3057 obj->value_["details"] = obj2;
3058 auto record = std::make_shared<Html>(UDType::HTML, obj);
3059 data.AddRecord(record);
3060 std::string key;
3061 status = UdmfClient::GetInstance().SetData(customOption, data, key);
3062 ASSERT_EQ(status, E_OK);
3063
3064 unifiedDataSet.clear();
3065 query = { .key = key, .intention = UD_INTENTION_DATA_HUB };
3066 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
3067 ASSERT_EQ(status, E_OK);
3068 ASSERT_EQ(unifiedDataSet.size(), 1);
3069 auto record2 = unifiedDataSet[0].GetRecordAt(0);
3070 ASSERT_NE(record2, nullptr);
3071 ASSERT_EQ(record2->GetType(), UDType::HTML);
3072 auto value = record2->GetValue();
3073
3074 ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&value), nullptr);
3075 obj = std::get<std::shared_ptr<Object>>(value);
3076
3077 ASSERT_NE(std::get_if<std::string>(&obj->value_["uniformDataType"]), nullptr);
3078 ASSERT_EQ(std::get<std::string>(obj->value_["uniformDataType"]), "general.html");
3079 ASSERT_NE(std::get_if<std::string>(&obj->value_["htmlContent"]), nullptr);
3080 ASSERT_EQ(std::get<std::string>(obj->value_["htmlContent"]), "www.xxx");
3081 ASSERT_NE(std::get_if<std::string>(&obj->value_["plainContent"]), nullptr);
3082 ASSERT_EQ(std::get<std::string>(obj->value_["plainContent"]), "htmlPlainContent");
3083
3084 ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&obj->value_["details"]), nullptr);
3085 obj2 = std::get<std::shared_ptr<Object>>(obj->value_["details"]);
3086
3087 ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail1"]), nullptr);
3088 ASSERT_EQ(std::get<std::string>(obj2->value_["detail1"]), "detail1");
3089 ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail2"]), nullptr);
3090 ASSERT_EQ(std::get<std::string>(obj2->value_["detail2"]), "detail2");
3091 LOG_INFO(UDMF_TEST, "QueryUDSData004 end.");
3092 }
3093
3094 /**
3095 * @tc.name: QueryUDSData005
3096 * @tc.desc: QueryUDSData005
3097 * @tc.type: FUNC
3098 */
3099 HWTEST_F(UdmfClientTest, QueryUDSData005, TestSize.Level1)
3100 {
3101 LOG_INFO(UDMF_TEST, "QueryUDSData005 begin.");
3102
3103 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
3104 std::vector<UnifiedData> unifiedDataSet;
3105 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
3106 ASSERT_EQ(status, E_OK);
3107 unifiedDataSet.clear();
3108 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
3109 ASSERT_EQ(status, E_OK);
3110 unifiedDataSet.clear();
3111
3112 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
3113 UnifiedData data;
3114 auto obj = std::make_shared<Object>();
3115 obj->value_["uniformDataType"] = "openharmony.app-item";
3116 obj->value_["appId"] = "app-itemAppId";
3117 obj->value_["appName"] = "app-itemAppName";
3118 obj->value_["appIconId"] = "app-itemAppIconId";
3119 obj->value_["appLabelId"] = "app-itemAppLabelId";
3120 obj->value_["bundleName"] = "app-itemBundleName";
3121 obj->value_["abilityName"] = "app-itemAbilityName";
3122 auto obj2 = std::make_shared<Object>();
3123 obj2->value_["detail1"] = "detail1";
3124 obj2->value_["detail2"] = 1234;
3125 obj->value_["details"] = obj2;
3126 auto record = std::make_shared<SystemDefinedAppItem>(UDType::SYSTEM_DEFINED_APP_ITEM, obj);
3127 data.AddRecord(record);
3128 std::string key;
3129 status = UdmfClient::GetInstance().SetData(customOption, data, key);
3130 ASSERT_EQ(status, E_OK);
3131
3132 unifiedDataSet.clear();
3133 query = { .key = key, .intention = UD_INTENTION_DATA_HUB };
3134 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
3135 ASSERT_EQ(status, E_OK);
3136 ASSERT_EQ(unifiedDataSet.size(), 1);
3137 auto record2 = unifiedDataSet[0].GetRecordAt(0);
3138 ASSERT_NE(record2, nullptr);
3139 ASSERT_EQ(record2->GetType(), UDType::SYSTEM_DEFINED_APP_ITEM);
3140 auto value = record2->GetValue();
3141
3142 ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&value), nullptr);
3143 obj = std::get<std::shared_ptr<Object>>(value);
3144
3145 ASSERT_NE(std::get_if<std::string>(&obj->value_["uniformDataType"]), nullptr);
3146 ASSERT_EQ(std::get<std::string>(obj->value_["uniformDataType"]), "openharmony.app-item");
3147 ASSERT_NE(std::get_if<std::string>(&obj->value_["appId"]), nullptr);
3148 ASSERT_EQ(std::get<std::string>(obj->value_["appId"]), "app-itemAppId");
3149 ASSERT_NE(std::get_if<std::string>(&obj->value_["appName"]), nullptr);
3150 ASSERT_EQ(std::get<std::string>(obj->value_["appName"]), "app-itemAppName");
3151 ASSERT_NE(std::get_if<std::string>(&obj->value_["appIconId"]), nullptr);
3152 ASSERT_EQ(std::get<std::string>(obj->value_["appIconId"]), "app-itemAppIconId");
3153 ASSERT_NE(std::get_if<std::string>(&obj->value_["appLabelId"]), nullptr);
3154 ASSERT_EQ(std::get<std::string>(obj->value_["appLabelId"]), "app-itemAppLabelId");
3155 ASSERT_NE(std::get_if<std::string>(&obj->value_["bundleName"]), nullptr);
3156 ASSERT_EQ(std::get<std::string>(obj->value_["bundleName"]), "app-itemBundleName");
3157 ASSERT_NE(std::get_if<std::string>(&obj->value_["abilityName"]), nullptr);
3158 ASSERT_EQ(std::get<std::string>(obj->value_["abilityName"]), "app-itemAbilityName");
3159
3160 ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&obj->value_["details"]), nullptr);
3161 obj2 = std::get<std::shared_ptr<Object>>(obj->value_["details"]);
3162
3163 ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail1"]), nullptr);
3164 ASSERT_EQ(std::get<std::string>(obj2->value_["detail1"]), "detail1");
3165 ASSERT_NE(std::get_if<int32_t>(&obj2->value_["detail2"]), nullptr);
3166 ASSERT_EQ(std::get<int32_t>(obj2->value_["detail2"]), 1234);
3167 LOG_INFO(UDMF_TEST, "QueryUDSData005 end.");
3168 }
3169
3170 /**
3171 * @tc.name: GetSelfBundleName001
3172 * @tc.desc: Nrmal testcase of GetSelfBundleName
3173 * @tc.type: FUNC
3174 */
3175 HWTEST_F(UdmfClientTest, GetSelfBundleName001, TestSize.Level1)
3176 {
3177 LOG_INFO(UDMF_TEST, "GetSelfBundleName001 begin.");
3178 UdmfClient udmfClient;
3179 std::string ret = udmfClient.GetSelfBundleName();
3180 EXPECT_NE(ret, "");
3181 LOG_INFO(UDMF_TEST, "GetSelfBundleName001 end.");
3182 }
3183
3184 /**
3185 * @tc.name: GetSummary004
3186 * @tc.desc: Get summary data for entries
3187 * @tc.type: FUNC
3188 */
3189 HWTEST_F(UdmfClientTest, GetSummary004, TestSize.Level1)
3190 {
3191 LOG_INFO(UDMF_TEST, "GetSummary004 begin.");
3192 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
3193 UnifiedData data;
3194 std::string key;
3195 UDDetails details;
3196 details.insert({ "udmf_key", "udmf_value" });
3197 std::shared_ptr<Object> obj = std::make_shared<Object>();
3198 obj->value_[UNIFORM_DATA_TYPE] = "general.file-uri";
3199 obj->value_[FILE_URI_PARAM] = "http://demo.com";
3200 obj->value_[FILE_TYPE] = "abcdefg";
3201 auto record = std::make_shared<UnifiedRecord>(FILE_URI, obj);
3202 auto plainText = PlainText("content", "abstract");
3203 auto size1 = plainText.GetSize();
3204 plainText.InitObject();
3205 record->AddEntry(plainText.GetUtdId2(), plainText.GetOriginValue());
3206 auto image = Image("uri");
3207 image.SetDetails(details);
3208 auto size2 = image.GetSize();
3209 image.InitObject();
3210 record->AddEntry(image.GetUtdId2(), image.GetOriginValue());
3211 std::vector<uint8_t> raw = {1, 2, 3, 4, 5};
3212 SystemDefinedPixelMap pixelMap = SystemDefinedPixelMap(raw);
3213 pixelMap.SetDetails(details);
3214 auto size3 = pixelMap.GetSize();
3215 pixelMap.InitObject();
3216 record->AddEntry(pixelMap.GetUtdId2(), pixelMap.GetOriginValue());
3217 raw = {1, 2, 3, 4, 5};
3218 auto applicationDefinedRecord = ApplicationDefinedRecord("my.type", raw);
3219 auto size4 = applicationDefinedRecord.GetSize();
3220 applicationDefinedRecord.InitObject();
3221 record->AddEntry(applicationDefinedRecord.GetUtdId2(), applicationDefinedRecord.GetOriginValue());
3222 data.AddRecord(record);
3223 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
3224 ASSERT_EQ(status, E_OK);
3225 QueryOption option2 = { .key = key };
3226 Summary summary;
3227 status = UdmfClient::GetInstance().GetSummary(option2, summary);
3228 ASSERT_EQ(status, E_OK);
3229 EXPECT_EQ(summary.summary["general.plain-text"], size1);
3230 EXPECT_EQ(summary.summary["general.image"], size2);
3231 EXPECT_EQ(summary.summary["openharmony.pixel-map"], size3);
3232 EXPECT_EQ(summary.summary["ApplicationDefinedType"], size4);
3233 EXPECT_EQ(summary.totalSize, record->GetSize());
3234 UnifiedData readData;
3235 status = UdmfClient::GetInstance().GetData(option2, readData);
3236 ASSERT_EQ(E_OK, status);
3237 ASSERT_EQ(1, readData.GetRecords().size());
3238 auto readRecord = readData.GetRecordAt(0);
3239 auto entries = readRecord->GetEntries();
3240 ASSERT_EQ(4, entries->size());
3241 auto readFileUri = std::get<std::shared_ptr<Object>>(entries->at("general.file-uri"));
3242 EXPECT_EQ("general.image", std::get<std::string>(readFileUri->value_[FILE_TYPE]));
3243 EXPECT_EQ("uri", std::get<std::string>(readFileUri->value_[ORI_URI]));
3244 auto readPlainText = std::get<std::shared_ptr<Object>>(entries->at("general.plain-text"));
3245 EXPECT_EQ("abstract", std::get<std::string>(readPlainText->value_[ABSTRACT]));
3246 auto readPixelMap = std::get<std::shared_ptr<Object>>(entries->at("openharmony.pixel-map"));
3247 EXPECT_EQ(5, std::get<std::vector<uint8_t>>(readPixelMap->value_[PIXEL_MAP]).size());
3248 auto readDefinedRecord = std::get<std::shared_ptr<Object>>(entries->at("my.type"));
3249 EXPECT_EQ(5, std::get<std::vector<uint8_t>>(readDefinedRecord->value_[ARRAY_BUFFER]).size());
3250 auto valueType = readRecord->GetValue();
3251 EXPECT_TRUE(std::holds_alternative<std::monostate>(readRecord->GetValue()));
3252 LOG_INFO(UDMF_TEST, "GetSummary004 end.");
3253 }
3254
3255 /**
3256 * @tc.name: GetSummary005
3257 * @tc.desc: Get summary data for entries
3258 * @tc.type: FUNC
3259 */
3260 HWTEST_F(UdmfClientTest, GetSummary005, TestSize.Level1)
3261 {
3262 LOG_INFO(UDMF_TEST, "GetSummary005 begin.");
3263
3264 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
3265 UnifiedData data;
3266 std::string key;
3267
3268 UDDetails details;
3269 details.insert({ "udmf_key", "udmf_value" });
3270
3271 auto record = std::make_shared<Html>("content1", "content2");
3272 auto size0 = record->GetSize();
3273
3274 auto link = Link("url", "descritpion");
3275 auto size1 = link.GetSize();
3276 link.InitObject();
3277 record->AddEntry(link.GetUtdId2(), link.GetOriginValue());
3278
3279 auto folder = Folder("uri");
3280 folder.SetDetails(details);
3281 auto size2 = folder.GetSize();
3282 folder.InitObject();
3283 record->AddEntry(folder.GetUtdId2(), folder.GetOriginValue());
3284
3285 std::vector<uint8_t> raw = {1, 2, 3, 4, 5};
3286 auto applicationDefinedRecord1 = ApplicationDefinedRecord("your.type", raw);
3287 auto size3 = applicationDefinedRecord1.GetSize();
3288 applicationDefinedRecord1.InitObject();
3289 record->AddEntry(applicationDefinedRecord1.GetUtdId2(), applicationDefinedRecord1.GetOriginValue());
3290
3291 raw = {1, 2, 3, 4, 5};
3292 auto applicationDefinedRecord2 = ApplicationDefinedRecord("my.type", raw);
3293 auto size4 = applicationDefinedRecord2.GetSize();
3294 applicationDefinedRecord2.InitObject();
3295 record->AddEntry(applicationDefinedRecord2.GetUtdId2(), applicationDefinedRecord2.GetOriginValue());
3296
3297 auto form = SystemDefinedForm();
3298 form.SetDetails(details);
3299 form.SetDetails(details);
3300 form.SetFormId(123);
3301 form.SetFormName("formName");
3302 form.SetModule("module");
3303 form.SetAbilityName("abilityName");
3304 form.SetBundleName("bundleName");
3305 auto size5 = form.GetSize();
3306 form.InitObject();
3307 record->AddEntry(form.GetUtdId2(), form.GetOriginValue());
3308
3309 raw = {1, 2, 3, 4, 5};
3310 std::shared_ptr<Object> obj = std::make_shared<Object>();
3311 obj->value_[UNIFORM_DATA_TYPE] = "general.content-form";
3312 obj->value_[THUMB_DATA] = raw;
3313 obj->value_[THUMB_DATA_LENGTH] = 5;
3314 obj->value_[DESCRIPTION] = "descritpion";
3315 obj->value_[TITLE] = "title";
3316 obj->value_[APP_ICON] = raw;
3317 obj->value_[APP_ICON_LENGTH] = 5;
3318 obj->value_[APP_NAME] = "appName";
3319 obj->value_[LINK_URL] = "linkUri";
3320 auto contentForm = UnifiedRecord(CONTENT_FORM, obj);
3321 auto size6 = contentForm.GetSize();
3322 record->AddEntry(contentForm.GetUtdId(), contentForm.GetOriginValue());
3323
3324 data.AddRecord(record);
3325
3326 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
3327 ASSERT_EQ(status, E_OK);
3328
3329 QueryOption option2 = { .key = key };
3330 Summary summary;
3331 status = UdmfClient::GetInstance().GetSummary(option2, summary);
3332
3333 LOG_INFO(UDMF_TEST, "GetSummary005 GetSummary.");
3334
3335 ASSERT_EQ(status, E_OK);
3336 EXPECT_EQ(summary.summary["general.html"], size0);
3337 EXPECT_EQ(summary.summary["general.hyperlink"], size1);
3338 EXPECT_EQ(summary.summary["general.folder"], size2);
3339 EXPECT_EQ(summary.summary["ApplicationDefinedType"], size3 + size4);
3340 EXPECT_EQ(summary.summary["openharmony.form"], size5);
3341 EXPECT_EQ(summary.summary["general.content-form"], size6);
3342
3343 EXPECT_EQ(summary.totalSize, record->GetSize());
3344
3345 UnifiedData readData;
3346 status = UdmfClient::GetInstance().GetData(option2, readData);
3347 LOG_INFO(UDMF_TEST, "GetSummary005 GetSummary1.");
3348 ASSERT_EQ(E_OK, status);
3349 ASSERT_EQ(1, readData.GetRecords().size());
3350 auto readRecord = readData.GetRecordAt(0);
3351 ValueType recordVal = readRecord->GetValue();
3352 auto entries = readRecord->GetEntries();
3353 ASSERT_EQ(7, entries->size());
3354 auto readHtml = std::get<std::shared_ptr<Object>>(entries->at("general.html"));
3355 EXPECT_EQ("content1", std::get<std::string>(readHtml->value_[HTML_CONTENT]));
3356 auto readHyperlink = std::get<std::shared_ptr<Object>>(entries->at("general.hyperlink"));
3357 EXPECT_EQ("descritpion", std::get<std::string>(readHyperlink->value_[DESCRIPTION]));
3358 auto readFolder = std::get<std::shared_ptr<Object>>(entries->at("general.file-uri"));
3359 EXPECT_EQ("uri", std::get<std::string>(readFolder->value_[ORI_URI]));
3360 auto readDefinedRecord = std::get<std::shared_ptr<Object>>(entries->at("your.type"));
3361 EXPECT_EQ(5, std::get<std::vector<uint8_t>>(readDefinedRecord->value_[ARRAY_BUFFER]).size());
3362 auto readDefinedRecord2 = std::get<std::shared_ptr<Object>>(entries->at("my.type"));
3363 EXPECT_EQ(5, std::get<std::vector<uint8_t>>(readDefinedRecord2->value_[ARRAY_BUFFER]).size());
3364 auto readForm = std::get<std::shared_ptr<Object>>(entries->at("openharmony.form"));
3365 EXPECT_EQ("module", std::get<std::string>(readForm->value_[MODULE]));
3366 auto readCotentForm = std::get<std::shared_ptr<Object>>(entries->at("general.content-form"));
3367 EXPECT_EQ("title", std::get<std::string>(readCotentForm->value_[TITLE]));
3368 LOG_INFO(UDMF_TEST, "GetSummary005 end.");
3369 }
3370
3371
3372 /**
3373 * @tc.name: FileUriCastTest001
3374 * @tc.desc: Cast file uri type record to verify works well
3375 * @tc.type: FUNC
3376 */
3377 HWTEST_F(UdmfClientTest, FileUriCastTest001, TestSize.Level1)
3378 {
3379 LOG_INFO(UDMF_TEST, "FileUriCastTest001 begin.");
3380 UnifiedData data;
3381 GetFileUriUnifiedData(data);
3382 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
3383 std::string key;
3384 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
3385 ASSERT_EQ(status, E_OK);
3386 QueryOption option2 = { .key = key };
3387 UnifiedData readData;
3388 status = UdmfClient::GetInstance().GetData(option2, readData);
3389 auto record0 = readData.GetRecordAt(0);
3390 auto fileValue = record0->GetValue();
3391 std::shared_ptr<Object> fileObj = std::get<std::shared_ptr<Object>>(fileValue);
3392 EXPECT_EQ(std::get<std::string>(fileObj->value_[FILE_URI_PARAM]), "http://demo.com");
3393 EXPECT_EQ(std::get<std::string>(fileObj->value_[FILE_TYPE]), "abcdefg");
3394 File *file = reinterpret_cast<File *>(record0.get());
3395 EXPECT_EQ(file->GetUri(), "http://demo.com");
3396 auto record1 = readData.GetRecordAt(1);
3397 auto imageValue = record1->GetValue();
3398 std::shared_ptr<Object> imageObj = std::get<std::shared_ptr<Object>>(imageValue);
3399 EXPECT_EQ(std::get<std::string>(imageObj->value_[FILE_URI_PARAM]), "http://demo.com");
3400 EXPECT_EQ(std::get<std::string>(imageObj->value_[FILE_TYPE]), "general.image");
3401 File *image = reinterpret_cast<Image *>(record1.get());
3402 EXPECT_EQ(image->GetUri(), "http://demo.com");
3403 auto record2 = readData.GetRecordAt(2);
3404 File *audio = reinterpret_cast<Audio *>(record2.get());
3405 EXPECT_EQ(audio->GetUri(), "http://demo.com");
3406 LOG_INFO(UDMF_TEST, "FileUriCastTest001 end.");
3407 }
3408
3409 /**
3410 * @tc.name: SetBatchData001
3411 * @tc.desc: Set 2k record and get data
3412 * @tc.type: FUNC
3413 */
3414 HWTEST_F(UdmfClientTest, SetBatchData001, TestSize.Level1)
3415 {
3416 LOG_INFO(UDMF_TEST, "SetBatchData001 begin.");
3417 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
3418 UnifiedData data1;
3419 std::string key;
3420 for (int32_t i = 0; i < BATCH_SIZE_2K; ++i) {
3421 auto file1 = std::make_shared<File>();
3422 file1->SetRemoteUri("remoteUri");
3423 UDDetails details1;
3424 details1.insert({ "udmf_key", "udmf_value" });
3425 file1->SetDetails(details1);
3426 data1.AddRecord(file1);
3427 }
3428 auto start = std::chrono::high_resolution_clock::now();
3429 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
3430 ASSERT_EQ(status, E_OK);
3431 auto end = std::chrono::high_resolution_clock::now();
3432 std::chrono::duration<double> du = end - start;
3433 double duration = BASE_CONVERSION * du.count();
3434 LOG_INFO(UDMF_TEST, "setDataDuration = %{public}.1f ms.", duration);
3435
3436 QueryOption option2 = { .key = key };
3437 Summary summary;
3438 start = std::chrono::high_resolution_clock::now();
3439 status = UdmfClient::GetInstance().GetSummary(option2, summary);
3440 end = std::chrono::high_resolution_clock::now();
3441 du = end - start;
3442 duration = BASE_CONVERSION * du.count();
3443 LOG_INFO(UDMF_TEST, "getSummaryDuration = %{public}.1f ms.", duration);
3444
3445 start = std::chrono::high_resolution_clock::now();
3446 AddPrivilege(option2);
3447 end = std::chrono::high_resolution_clock::now();
3448 du = end - start;
3449 duration = BASE_CONVERSION * du.count();
3450 LOG_INFO(UDMF_TEST, "addPrivilegeDuration = %{public}.1f ms.", duration);
3451
3452 SetHapToken2();
3453 UnifiedData data2;
3454 start = std::chrono::high_resolution_clock::now();
3455 status = UdmfClient::GetInstance().GetData(option2, data2);
3456 ASSERT_EQ(status, E_OK);
3457 end = std::chrono::high_resolution_clock::now();
3458 du = end - start;
3459 duration = BASE_CONVERSION * du.count();
3460 LOG_INFO(UDMF_TEST, "getDataDuration = %{public}.1f ms.", duration);
3461
3462 ASSERT_EQ(data2.GetRecords().size(), BATCH_SIZE_2K);
3463 for (auto record : data2.GetRecords()) {
3464 ASSERT_NE(record, nullptr);
3465 EXPECT_EQ(record->GetType(), UDType::FILE);
3466 }
3467 LOG_INFO(UDMF_TEST, "SetBatchData001 end.");
3468 }
3469
3470 /**
3471 * @tc.name: SetBatchData002
3472 * @tc.desc: Set 5k record and get data
3473 * @tc.type: FUNC
3474 */
3475 HWTEST_F(UdmfClientTest, SetBatchData002, TestSize.Level1)
3476 {
3477 LOG_INFO(UDMF_TEST, "SetBatchData002 begin.");
3478 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
3479 UnifiedData data1;
3480 std::string key;
3481 for (int32_t i = 0; i < BATCH_SIZE_5K; ++i) {
3482 auto file1 = std::make_shared<File>();
3483 file1->SetRemoteUri("remoteUri");
3484 UDDetails details1;
3485 details1.insert({ "udmf_key", "udmf_value" });
3486 file1->SetDetails(details1);
3487 data1.AddRecord(file1);
3488 }
3489 auto start = std::chrono::high_resolution_clock::now();
3490 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
3491 ASSERT_EQ(status, E_OK);
3492 auto end = std::chrono::high_resolution_clock::now();
3493 std::chrono::duration<double> du = end - start;
3494 double duration = BASE_CONVERSION * du.count();
3495 LOG_INFO(UDMF_TEST, "setDataDuration = %{public}.1f ms.", duration);
3496
3497 QueryOption option2 = { .key = key };
3498 Summary summary;
3499 start = std::chrono::high_resolution_clock::now();
3500 status = UdmfClient::GetInstance().GetSummary(option2, summary);
3501 end = std::chrono::high_resolution_clock::now();
3502 du = end - start;
3503 duration = BASE_CONVERSION * du.count();
3504 LOG_INFO(UDMF_TEST, "getSummaryDuration = %{public}.1f ms.", duration);
3505
3506 start = std::chrono::high_resolution_clock::now();
3507 AddPrivilege(option2);
3508 end = std::chrono::high_resolution_clock::now();
3509 du = end - start;
3510 duration = BASE_CONVERSION * du.count();
3511 LOG_INFO(UDMF_TEST, "addPrivilegeDuration = %{public}.1f ms.", duration);
3512
3513 SetHapToken2();
3514 UnifiedData data2;
3515 start = std::chrono::high_resolution_clock::now();
3516 status = UdmfClient::GetInstance().GetData(option2, data2);
3517 ASSERT_EQ(status, E_OK);
3518 end = std::chrono::high_resolution_clock::now();
3519 du = end - start;
3520 duration = BASE_CONVERSION * du.count();
3521 LOG_INFO(UDMF_TEST, "getDataDuration = %{public}.1f ms.", duration);
3522
3523 ASSERT_EQ(data2.GetRecords().size(), BATCH_SIZE_5K);
3524 for (auto record : data2.GetRecords()) {
3525 ASSERT_NE(record, nullptr);
3526 EXPECT_EQ(record->GetType(), UDType::FILE);
3527 }
3528 LOG_INFO(UDMF_TEST, "SetBatchData002 end.");
3529 }
3530
3531 /**
3532 * @tc.name: GetData002
3533 * @tc.desc: test Marshalling and Unmarshalling properties drag
3534 * @tc.type: FUNC
3535 */
3536 HWTEST_F(UdmfClientTest, GetData002, TestSize.Level1)
3537 {
3538 LOG_INFO(UDMF_TEST, "GetData002 begin.");
3539
3540 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
3541 UnifiedData data;
3542 std::string key;
3543 auto record = std::make_shared<Html>("htmlContent", "plainContent");
3544 auto link = Link("url", "descritpion");
3545 link.InitObject();
3546 record->AddEntry(link.GetUtdId(), link.GetOriginValue());
3547 data.AddRecord(record);
3548 std::shared_ptr<UnifiedDataProperties> properties = std::make_shared<UnifiedDataProperties>();
3549 std::string tag = "this is a tag of test GetData002";
3550 properties->tag = tag;
3551 properties->shareOptions = CROSS_APP;
3552 data.SetProperties(std::move(properties));
3553 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
3554 ASSERT_EQ(status, E_OK);
3555
3556 QueryOption option2 = { .key = key };
3557 UnifiedData readData;
3558 status = UdmfClient::GetInstance().GetData(option2, readData);
3559 ASSERT_EQ(status, E_OK);
3560 ASSERT_EQ(readData.GetRecords().size(), 1);
3561 auto readRecord = readData.GetRecordAt(0);
3562 ASSERT_NE(readRecord, nullptr);
3563 auto entries = readRecord->GetEntries();
3564 auto readHtml = std::get<std::shared_ptr<Object>>(entries->at("general.html"));
3565 EXPECT_EQ("htmlContent", std::get<std::string>(readHtml->value_[HTML_CONTENT]));
3566 auto readHyperlink = std::get<std::shared_ptr<Object>>(entries->at("general.hyperlink"));
3567 EXPECT_EQ("descritpion", std::get<std::string>(readHyperlink->value_[DESCRIPTION]));
3568 auto readProperties = readData.GetProperties();
3569 ASSERT_NE(readProperties, nullptr);
3570 EXPECT_EQ(readProperties->tag, tag);
3571 EXPECT_EQ(readProperties->shareOptions, CROSS_APP);
3572
3573 LOG_INFO(UDMF_TEST, "GetData002 end.");
3574 }
3575
3576 /**
3577 * @tc.name: GetBatchData001
3578 * @tc.desc: test Marshalling and Unmarshalling properties datahub
3579 * @tc.type: FUNC
3580 */
3581 HWTEST_F(UdmfClientTest, GetBatchData001, TestSize.Level1)
3582 {
3583 LOG_INFO(UDMF_TEST, "GetBatchData001 begin.");
3584
3585 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
3586 std::vector<UnifiedData> unifiedDataSet;
3587 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
3588 ASSERT_EQ(status, E_OK);
3589 unifiedDataSet.clear();
3590 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
3591 ASSERT_EQ(status, E_OK);
3592 unifiedDataSet.clear();
3593
3594 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
3595 UnifiedData data;
3596 std::shared_ptr<UnifiedRecord> record = std::make_shared<PlainText>(UDType::PLAIN_TEXT, "plainTextContent");
3597 data.AddRecord(record);
3598 std::shared_ptr<UnifiedDataProperties> properties = std::make_shared<UnifiedDataProperties>();
3599 std::string tag = "this is a tag of test GetBatchData001";
3600 properties->tag = tag;
3601 properties->shareOptions = CROSS_APP;
3602 data.SetProperties(std::move(properties));
3603 std::string key;
3604 status = UdmfClient::GetInstance().SetData(customOption, data, key);
3605 ASSERT_EQ(status, E_OK);
3606 query = { .key = key, .intention = Intention::UD_INTENTION_DATA_HUB };
3607 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
3608 ASSERT_EQ(status, E_OK);
3609 ASSERT_EQ(unifiedDataSet.size(), 1);
3610 auto record2 = unifiedDataSet[0].GetRecordAt(0);
3611 ValueType value = record2->GetValue();
3612 ASSERT_NE(std::get_if<std::string>(&value), nullptr);
3613 EXPECT_EQ(std::get<std::string>(value), "plainTextContent");
3614 auto readProperties = unifiedDataSet[0].GetProperties();
3615 ASSERT_NE(readProperties, nullptr);
3616 EXPECT_EQ(readProperties->tag, tag);
3617 EXPECT_EQ(readProperties->shareOptions, CROSS_APP);
3618
3619 LOG_INFO(UDMF_TEST, "GetBatchData001 end.");
3620 }
3621
3622 /**
3623 * @tc.name: UpdateData003
3624 * @tc.desc: test update data properties
3625 * @tc.type: FUNC
3626 */
3627 HWTEST_F(UdmfClientTest, UpdateData003, TestSize.Level1)
3628 {
3629 LOG_INFO(UDMF_TEST, "UpdateData003 begin.");
3630 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
3631 std::vector<UnifiedData> unifiedDataSet;
3632 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
3633 ASSERT_EQ(status, E_OK);
3634 unifiedDataSet.clear();
3635 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
3636 ASSERT_EQ(status, E_OK);
3637 unifiedDataSet.clear();
3638 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
3639 UnifiedData data;
3640 std::shared_ptr<UnifiedRecord> record = std::make_shared<PlainText>(UDType::PLAIN_TEXT, "plainTextContent");
3641 data.AddRecord(record);
3642 std::shared_ptr<UnifiedDataProperties> properties = std::make_shared<UnifiedDataProperties>();
3643 std::string tag = "this is a tag of test UpdateData003";
3644 properties->tag = tag;
3645 data.SetProperties(std::move(properties));
3646 std::string key;
3647 status = UdmfClient::GetInstance().SetData(customOption, data, key);
3648 ASSERT_EQ(status, E_OK);
3649 query = { .key = key, .intention = Intention::UD_INTENTION_DATA_HUB };
3650 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
3651 ASSERT_EQ(status, E_OK);
3652 ASSERT_EQ(unifiedDataSet.size(), 1);
3653 auto readProperties = unifiedDataSet[0].GetProperties();
3654 ASSERT_NE(readProperties, nullptr);
3655 EXPECT_EQ(readProperties->tag, tag);
3656 std::shared_ptr<UnifiedDataProperties> properties1 = std::make_shared<UnifiedDataProperties>();
3657 std::string tag1 = "this is a tag of test UpdateData003test";
3658 properties1->tag = tag1;
3659 data.SetProperties(std::move(properties1));
3660 status = UdmfClient::GetInstance().UpdateData(query, data);
3661 ASSERT_EQ(status, E_OK);
3662 unifiedDataSet.clear();
3663 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
3664 ASSERT_EQ(status, E_OK);
3665 ASSERT_EQ(unifiedDataSet.size(), 1);
3666 auto readProperties1 = unifiedDataSet[0].GetProperties();
3667 ASSERT_NE(readProperties1, nullptr);
3668 EXPECT_EQ(readProperties1->tag, tag1);
3669 status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
3670 ASSERT_EQ(status, E_OK);
3671 unifiedDataSet.clear();
3672 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
3673 ASSERT_EQ(status, E_OK);
3674 ASSERT_TRUE(unifiedDataSet.empty());
3675 LOG_INFO(UDMF_TEST, "UpdateData003 end.");
3676 }
3677
3678 /**
3679 * @tc.name: SetData036
3680 * @tc.desc: test set html type data image src is base64 format
3681 * @tc.type: FUNC
3682 */
3683 HWTEST_F(UdmfClientTest, SetData036, TestSize.Level1)
3684 {
3685 LOG_INFO(UDMF_TEST, "SetData036 begin.");
3686
3687 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
3688 UnifiedData data;
3689 std::string key;
3690 std::shared_ptr<Object> obj = std::make_shared<Object>();
3691 obj->value_[UNIFORM_DATA_TYPE] = "general.file-uri";
3692 obj->value_[FILE_URI_PARAM] = "http://demo.com";
3693 auto record = std::make_shared<UnifiedRecord>(FILE_URI, obj);
3694 std::string html = "<img data-ohos='clipboard' src='data:image/png;base64,IVBORw0KGgoAAAANSUhEUgAAAF'>";
3695 auto htmlRecord = Html(html, "abstract");
3696 htmlRecord.InitObject();
3697 record->AddEntry(htmlRecord.GetUtdId(), htmlRecord.GetOriginValue());
3698 data.AddRecord(record);
3699 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
3700 ASSERT_EQ(status, E_OK);
3701 QueryOption option2 = { .key = key };
3702 AddPrivilege1(option2);
3703 SetHapToken1();
3704 UnifiedData readData;
3705 status = UdmfClient::GetInstance().GetData(option2, readData);
3706 ASSERT_EQ(status, E_OK);
3707 std::shared_ptr<UnifiedRecord> readRecord = readData.GetRecordAt(0);
3708 ASSERT_NE(readRecord, nullptr);
3709 auto uris = readRecord->GetUris();
3710 EXPECT_EQ(uris.size(), 0);
3711
3712 LOG_INFO(UDMF_TEST, "SetData036 end.");
3713 }
3714
3715 /**
3716 * @tc.name: GetParentType001
3717 * @tc.desc: test Summary fileType
3718 * @tc.type: FUNC
3719 */
3720 HWTEST_F(UdmfClientTest, GetParentType001, TestSize.Level1)
3721 {
3722 LOG_INFO(UDMF_TEST, "GetParentType001 begin.");
3723 Summary oldSummary;
3724 std::map<std::string, int64_t> sumMap = {
3725 { "general.file", 10 },
3726 { "general.png", 10 },
3727 { "general.html", 10 },
3728 { "general.jpeg", 10 },
3729 { "general.avi", 10 },
3730 { "com.adobe.pdf", 10 },
3731 { "general.text", 10 },
3732 { "aabbcc", 10 }
3733 };
3734 oldSummary.summary = std::move(sumMap);
3735 oldSummary.totalSize = 80;
3736 Summary newSummary;
3737 auto ret = UdmfClient::GetInstance().GetParentType(oldSummary, newSummary);
3738 ASSERT_EQ(ret, E_OK);
3739 EXPECT_EQ(newSummary.totalSize, 80);
3740 EXPECT_EQ(newSummary.summary["general.file"], 20);
3741 EXPECT_EQ(newSummary.summary["general.image"], 20);
3742 EXPECT_EQ(newSummary.summary["general.html"], 10);
3743 EXPECT_EQ(newSummary.summary["general.video"], 10);
3744 EXPECT_EQ(newSummary.summary["aabbcc"], 10);
3745 EXPECT_EQ(newSummary.summary["general.text"], 10);
3746 }
3747
3748 /**
3749 * @tc.name: GetBundleNameByUdKey001
3750 * @tc.desc: test GetBundleNameByUdKey with valid UD key
3751 * @tc.type: FUNC
3752 */
3753 HWTEST_F(UdmfClientTest, GetBundleNameByUdKey001, TestSize.Level1)
3754 {
3755 std::string key = "udmf://drag/com.example.app/N]2fIEMbrJj@<hH7zpXzzQ>wp:jMuPa7";
3756 std::string expectedBundle = "com.example.app";
3757
3758 std::string actualBundle = UdmfClient::GetInstance().GetBundleNameByUdKey(key);
3759 EXPECT_EQ(actualBundle, expectedBundle);
3760 }
3761
3762 /**
3763 * @tc.name: GetBundleNameByUdKey002
3764 * @tc.desc: test GetBundleNameByUdKey with invalid UD key (missing schema)
3765 * @tc.type: FUNC
3766 */
3767 HWTEST_F(UdmfClientTest, GetBundleNameByUdKey002, TestSize.Level1)
3768 {
3769 std::string key = "invalid://share/com.example.app/123";
3770 std::string actualBundle = UdmfClient::GetInstance().GetBundleNameByUdKey(key);
3771 EXPECT_EQ(actualBundle, "");
3772 }
3773
3774 /**
3775 * @tc.name: GetBundleNameByUdKey003
3776 * @tc.desc: test GetBundleNameByUdKey with incomplete key (missing parts)
3777 * @tc.type: FUNC
3778 */
3779 HWTEST_F(UdmfClientTest, GetBundleNameByUdKey003, TestSize.Level1)
3780 {
3781 std::string key = "udmf://share/com.example.app";
3782 std::string actualBundle = UdmfClient::GetInstance().GetBundleNameByUdKey(key);
3783 EXPECT_EQ(actualBundle, "");
3784 }
3785
3786 /**
3787 * @tc.name: GetBundleNameByUdKey004
3788 * @tc.desc: test GetBundleNameByUdKey with empty key
3789 * @tc.type: FUNC
3790 */
3791 HWTEST_F(UdmfClientTest, GetBundleNameByUdKey004, TestSize.Level1)
3792 {
3793 std::string key = "";
3794 std::string actualBundle = UdmfClient::GetInstance().GetBundleNameByUdKey(key);
3795 EXPECT_EQ(actualBundle, "");
3796 }
3797
3798 /**
3799 * @tc.name: GetBundleNameByUdKey005
3800 * @tc.desc: test GetBundleNameByUdKey with valid UD key
3801 * @tc.type: FUNC
3802 */
3803 HWTEST_F(UdmfClientTest, GetBundleNameByUdKey005, TestSize.Level1)
3804 {
3805 std::string key = "udmf://drag/+clone-1+com.example.app/N]2fIEMbrJj@<hH7zpXzzQ>wp:jMuPa7";
3806 std::string expectedBundle = "+clone-1+com.example.app";
3807
3808 std::string actualBundle = UdmfClient::GetInstance().GetBundleNameByUdKey(key);
3809 EXPECT_EQ(actualBundle, expectedBundle);
3810 }
3811
3812 /**
3813 * @tc.name: GetBundleNameByUdKey006
3814 * @tc.desc: test GetBundleNameByUdKey with valid UD key
3815 * @tc.type: FUNC
3816 */
3817 HWTEST_F(UdmfClientTest, GetBundleNameByUdKey006, TestSize.Level1)
3818 {
3819 std::string key = "udmf://drag/+clone-5+com.example.app/N]2fIEMbrJj@<hH7zpXzzQ>wp:jMuPa7";
3820 std::string expectedBundle = "+clone-5+com.example.app";
3821
3822 std::string actualBundle = UdmfClient::GetInstance().GetBundleNameByUdKey(key);
3823 EXPECT_EQ(actualBundle, expectedBundle);
3824 }
3825
3826 /**
3827 * @tc.name: ProcessDragIfInApp001
3828 * @tc.desc: test ProcessDragIfInApp with valid shareOption
3829 * @tc.type: FUNC
3830 */
3831 HWTEST_F(UdmfClientTest, ProcessDragIfInApp001, TestSize.Level1)
3832 {
3833 UnifiedData unifiedData;
3834 std::string intentionDrag = "drag";
3835 std::string key = "test";
3836
3837 EXPECT_NO_FATAL_FAILURE(UdmfClient::GetInstance().ProcessDragIfInApp(unifiedData, intentionDrag, key));
3838 }
3839
3840 /**
3841 * @tc.name: SetData0024
3842 * @tc.desc: test SetData with invalid intention
3843 * @tc.type: FUNC
3844 */
3845 HWTEST_F(UdmfClientTest, SetData0024, TestSize.Level1)
3846 {
3847 CustomOption option;
3848 UnifiedData unifiedData;
3849 std::string key = "test";
3850
3851 auto ret = UdmfClient::GetInstance().SetData(option, unifiedData, key);
3852 EXPECT_EQ(ret, Status::E_INVALID_PARAMETERS);
3853 }
3854
3855 /**
3856 * @tc.name: IsAppropriateType001
3857 * @tc.desc: test SetData with invalid intention
3858 * @tc.type: FUNC
3859 */
3860 HWTEST_F(UdmfClientTest, IsAppropriateType001, TestSize.Level1)
3861 {
3862 Summary totalSummary;
3863 std::map<std::string, int64_t> specificSummary = {
3864 { "general.png", 10 },
3865 { "general.jpg", 10 },
3866 { "general.html", 10 }
3867 };
3868 std::map<std::string, int64_t> summary = {
3869 { "general.image", 20 },
3870 { "general.html", 10 }
3871 };
3872 std::map<std::string, std::vector<int32_t>> summaryFormat = {
3873 { "general.png", { Uds_Type::UDS_FILE_URI } },
3874 { "general.jpg", { Uds_Type::UDS_FILE_URI } },
3875 { "general.html", { Uds_Type::UDS_HTML } }
3876 };
3877 totalSummary.summary = summary;
3878 totalSummary.specificSummary = specificSummary;
3879 totalSummary.summaryFormat = summaryFormat;
3880 totalSummary.version = 1;
3881 totalSummary.totalSize = 30;
3882
3883 std::vector<std::string> allowTypes = { "general.image" };
3884 bool isAppropriate = UdmfClient::GetInstance().IsAppropriateType(totalSummary, allowTypes);
3885 EXPECT_TRUE(isAppropriate);
3886
3887 allowTypes = { "general.hyperlink" };
3888 isAppropriate = UdmfClient::GetInstance().IsAppropriateType(totalSummary, allowTypes);
3889 EXPECT_FALSE(isAppropriate);
3890
3891 allowTypes = { "general.html" };
3892 isAppropriate = UdmfClient::GetInstance().IsAppropriateType(totalSummary, allowTypes);
3893 EXPECT_TRUE(isAppropriate);
3894 }
3895
3896 /**
3897 * @tc.name: IsAppropriateType002
3898 * @tc.desc: test SetData with invalid intention
3899 * @tc.type: FUNC
3900 */
3901 HWTEST_F(UdmfClientTest, IsAppropriateType002, TestSize.Level1)
3902 {
3903 Summary totalSummary;
3904 std::map<std::string, int64_t> specificSummary = {
3905 { "general.html", 10 }
3906 };
3907 std::map<std::string, int64_t> summary = {
3908 { "general.html", 10 }
3909 };
3910 std::map<std::string, std::vector<int32_t>> summaryFormat = {
3911 { "general.html", { Uds_Type::UDS_FILE_URI } }
3912 };
3913 totalSummary.summary = summary;
3914 totalSummary.specificSummary = specificSummary;
3915 totalSummary.summaryFormat = summaryFormat;
3916 totalSummary.version = 1;
3917 totalSummary.totalSize = 30;
3918
3919 std::vector<std::string> allowTypes = { "general.html" };
3920 bool isAppropriate = UdmfClient::GetInstance().IsAppropriateType(totalSummary, allowTypes);
3921 EXPECT_TRUE(isAppropriate);
3922
3923 allowTypes = { "general.file" };
3924 isAppropriate = UdmfClient::GetInstance().IsAppropriateType(totalSummary, allowTypes);
3925 EXPECT_TRUE(isAppropriate);
3926
3927 allowTypes = { "general.file-uri" };
3928 isAppropriate = UdmfClient::GetInstance().IsAppropriateType(totalSummary, allowTypes);
3929 EXPECT_TRUE(isAppropriate);
3930
3931 allowTypes = { "general.image" };
3932 isAppropriate = UdmfClient::GetInstance().IsAppropriateType(totalSummary, allowTypes);
3933 EXPECT_FALSE(isAppropriate);
3934
3935 totalSummary.version = 0;
3936 allowTypes = { "general.html" };
3937 isAppropriate = UdmfClient::GetInstance().IsAppropriateType(totalSummary, allowTypes);
3938 EXPECT_TRUE(isAppropriate);
3939
3940 allowTypes = { "general.file-uri" };
3941 isAppropriate = UdmfClient::GetInstance().IsAppropriateType(totalSummary, allowTypes);
3942 EXPECT_FALSE(isAppropriate);
3943
3944 allowTypes = { "general.image" };
3945 isAppropriate = UdmfClient::GetInstance().IsAppropriateType(totalSummary, allowTypes);
3946 EXPECT_FALSE(isAppropriate);
3947 }
3948
3949 /**
3950 * @tc.name: IsAppropriateType002
3951 * @tc.desc: test SetData with invalid intention
3952 * @tc.type: FUNC
3953 */
3954 HWTEST_F(UdmfClientTest, IsAppropriateType003, TestSize.Level1)
3955 {
3956 Summary totalSummary;
3957 std::map<std::string, int64_t> specificSummary = {
3958 { "general.html", 10 }
3959 };
3960 std::map<std::string, int64_t> summary = {
3961 { "general.html", 10 }
3962 };
3963 std::map<std::string, std::vector<int32_t>> summaryFormat = {
3964 { "general.html", { Uds_Type::UDS_HTML } }
3965 };
3966 totalSummary.summary = summary;
3967 totalSummary.specificSummary = specificSummary;
3968 totalSummary.summaryFormat = summaryFormat;
3969 totalSummary.version = 1;
3970 totalSummary.totalSize = 30;
3971
3972 std::vector<std::string> allowTypes = { "general.html" };
3973 bool isAppropriate = UdmfClient::GetInstance().IsAppropriateType(totalSummary, allowTypes);
3974 EXPECT_TRUE(isAppropriate);
3975
3976 allowTypes = { "general.file" };
3977 isAppropriate = UdmfClient::GetInstance().IsAppropriateType(totalSummary, allowTypes);
3978 EXPECT_FALSE(isAppropriate);
3979
3980 allowTypes = { "general.file-uri" };
3981 isAppropriate = UdmfClient::GetInstance().IsAppropriateType(totalSummary, allowTypes);
3982 EXPECT_FALSE(isAppropriate);
3983
3984 allowTypes = { "general.image" };
3985 isAppropriate = UdmfClient::GetInstance().IsAppropriateType(totalSummary, allowTypes);
3986 EXPECT_FALSE(isAppropriate);
3987
3988 totalSummary.version = 0;
3989 allowTypes = { "general.html" };
3990 isAppropriate = UdmfClient::GetInstance().IsAppropriateType(totalSummary, allowTypes);
3991 EXPECT_TRUE(isAppropriate);
3992
3993 allowTypes = { "general.file-uri" };
3994 isAppropriate = UdmfClient::GetInstance().IsAppropriateType(totalSummary, allowTypes);
3995 EXPECT_FALSE(isAppropriate);
3996
3997 allowTypes = { "general.image" };
3998 isAppropriate = UdmfClient::GetInstance().IsAppropriateType(totalSummary, allowTypes);
3999 EXPECT_FALSE(isAppropriate);
4000 }
4001
4002 /**
4003 * @tc.name: GetSummary006
4004 * @tc.desc: Get summary data for entries
4005 * @tc.type: FUNC
4006 */
4007 HWTEST_F(UdmfClientTest, GetSummary006, TestSize.Level1)
4008 {
4009 LOG_INFO(UDMF_TEST, "GetSummary006 begin.");
4010 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
4011 UnifiedData data;
4012 std::string key;
4013
4014 UDDetails details;
4015 details.insert({ "udmf_key", "udmf_value" });
4016
4017 auto record = std::make_shared<Html>("content1", "content2");
4018 auto size0 = record->GetSize();
4019
4020 auto folder = Folder("uri");
4021 folder.SetDetails(details);
4022 folder.InitObject();
4023 record->AddEntry(folder.GetUtdId2(), folder.GetOriginValue());
4024
4025 std::shared_ptr<Object> obj = std::make_shared<Object>();
4026 obj->value_[UNIFORM_DATA_TYPE] = "general.file-uri";
4027 obj->value_[FILE_URI_PARAM] = "http://demo.com";
4028 obj->value_[FILE_TYPE] = "general.html";
4029 auto size3 = ObjectUtils::GetValueSize(obj, false);
4030 record->AddEntry("general.file-uri", obj);
4031
4032 data.AddRecord(record);
4033
4034 std::shared_ptr<Object> obj1 = std::make_shared<Object>();
4035 obj1->value_[UNIFORM_DATA_TYPE] = "general.file-uri";
4036 obj1->value_[FILE_URI_PARAM] = "http://demo.com";
4037 obj1->value_[FILE_TYPE] = "general.plain-text";
4038 auto size4 = ObjectUtils::GetValueSize(obj1, false);
4039 auto record1 = std::make_shared<UnifiedRecord>(FILE_URI, obj1);
4040 data.AddRecord(record1);
4041
4042 std::shared_ptr<Object> obj2 = std::make_shared<Object>();
4043 obj2->value_[UNIFORM_DATA_TYPE] = "general.file-uri";
4044 obj2->value_[FILE_URI_PARAM] = "http://demo.com";
4045 obj2->value_[FILE_TYPE] = "general.png";
4046 auto size5 = ObjectUtils::GetValueSize(obj2, false);
4047 auto record2 = std::make_shared<UnifiedRecord>(FILE_URI, obj2);
4048 data.AddRecord(record2);
4049
4050 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
4051 ASSERT_EQ(status, E_OK);
4052
4053 QueryOption option2 = { .key = key };
4054 Summary summary;
4055 status = UdmfClient::GetInstance().GetSummary(option2, summary);
4056
4057 ASSERT_EQ(status, E_OK);
4058 EXPECT_EQ(summary.summary["general.html"], size0);
4059 EXPECT_EQ(summary.summary["general.folder"], 0);
4060 EXPECT_EQ(summary.summary["general.file"], size3 + size4);
4061 EXPECT_EQ(summary.summary["general.image"], size5);
4062
4063 EXPECT_EQ(summary.specificSummary["general.html"], size0 + size3);
4064 EXPECT_EQ(summary.specificSummary["general.folder"], 0);
4065 EXPECT_EQ(summary.specificSummary["general.plain-text"], size4);
4066 EXPECT_EQ(summary.specificSummary["general.png"], size5);
4067 EXPECT_EQ(summary.totalSize, record->GetSize() + record1->GetSize() + record2->GetSize());
4068
4069 EXPECT_EQ(summary.version, 1);
4070 auto htmlFormat = summary.summaryFormat["general.html"];
4071 EXPECT_TRUE(std::find(htmlFormat.begin(), htmlFormat.end(), Uds_Type::UDS_FILE_URI) != htmlFormat.end());
4072 EXPECT_TRUE(std::find(htmlFormat.begin(), htmlFormat.end(), Uds_Type::UDS_HTML) != htmlFormat.end());
4073
4074 auto textFormat = summary.summaryFormat["general.plain-text"];
4075 EXPECT_TRUE(std::find(textFormat.begin(), textFormat.end(), Uds_Type::UDS_FILE_URI) != textFormat.end());
4076
4077 auto pngFormat = summary.summaryFormat["general.png"];
4078 EXPECT_TRUE(std::find(pngFormat.begin(), pngFormat.end(), Uds_Type::UDS_FILE_URI) != pngFormat.end());
4079 LOG_INFO(UDMF_TEST, "GetSummary006 end.");
4080 }
4081 } // OHOS::Test
