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 "folder.h"
33 #include "html.h"
34 #include "image.h"
35 #include "link.h"
36 #include "plain_text.h"
37 #include "system_defined_appitem.h"
38 #include "system_defined_form.h"
39 #include "system_defined_pixelmap.h"
40 #include "system_defined_record.h"
41 #include "text.h"
42 #include "unified_data_helper.h"
43 #include "video.h"
44
45 using namespace testing::ext;
46 using namespace OHOS::Security::AccessToken;
47 using namespace OHOS::UDMF;
48 using namespace OHOS;
49 namespace OHOS::Test {
50 constexpr int SLEEP_TIME = 50; // 50 ms
51 class UdmfClientTest : public testing::Test {
52 public:
53 static void SetUpTestCase();
54 static void TearDownTestCase();
55 void SetUp() override;
56 void TearDown() override;
57
58 void SetNativeToken(const std::string &processName);
59 static void AllocHapToken1();
60 static void AllocHapToken2();
61 void SetHapToken1();
62 void SetHapToken2();
63
64 void AddPrivilege(QueryOption &option);
65 void CompareDetails(const UDDetails &details);
66 void GetEmptyData(QueryOption &option);
67
68 static constexpr int USER_ID = 100;
69 static constexpr int INST_INDEX = 0;
70 };
71
SetUpTestCase()72 void UdmfClientTest::SetUpTestCase()
73 {
74 AllocHapToken1();
75 AllocHapToken2();
76 }
77
TearDownTestCase()78 void UdmfClientTest::TearDownTestCase()
79 {
80 auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo1", INST_INDEX);
81 AccessTokenKit::DeleteToken(tokenId);
82 tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo2", INST_INDEX);
83 AccessTokenKit::DeleteToken(tokenId);
84 }
85
SetUp()86 void UdmfClientTest::SetUp()
87 {
88 SetHapToken1();
89 }
90
TearDown()91 void UdmfClientTest::TearDown()
92 {
93 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
94 std::vector<UnifiedData> unifiedDataSet;
95 UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
96 query = { .intention = Intention::UD_INTENTION_DRAG };
97 UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
98 }
99
SetNativeToken(const std::string & processName)100 void UdmfClientTest::SetNativeToken(const std::string &processName)
101 {
102 auto tokenId = AccessTokenKit::GetNativeTokenId(processName);
103 SetSelfTokenID(tokenId);
104 }
105
AllocHapToken1()106 void UdmfClientTest::AllocHapToken1()
107 {
108 HapInfoParams info = {
109 .userID = USER_ID,
110 .bundleName = "ohos.test.demo1",
111 .instIndex = INST_INDEX,
112 .appIDDesc = "ohos.test.demo1"
113 };
114
115 HapPolicyParams policy = {
116 .apl = APL_NORMAL,
117 .domain = "test.domain",
118 .permList = {
119 {
120 .permissionName = "ohos.permission.test",
121 .bundleName = "ohos.test.demo1",
122 .grantMode = 1,
123 .availableLevel = APL_NORMAL,
124 .label = "label",
125 .labelId = 1,
126 .description = "test1",
127 .descriptionId = 1
128 }
129 },
130 .permStateList = {
131 {
132 .permissionName = "ohos.permission.test",
133 .isGeneral = true,
134 .resDeviceID = { "local" },
135 .grantStatus = { PermissionState::PERMISSION_GRANTED },
136 .grantFlags = { 1 }
137 }
138 }
139 };
140 auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
141 SetSelfTokenID(tokenID.tokenIDEx);
142 }
143
AllocHapToken2()144 void UdmfClientTest::AllocHapToken2()
145 {
146 HapInfoParams info = {
147 .userID = USER_ID,
148 .bundleName = "ohos.test.demo2",
149 .instIndex = INST_INDEX,
150 .appIDDesc = "ohos.test.demo2"
151 };
152
153 HapPolicyParams policy = {
154 .apl = APL_NORMAL,
155 .domain = "test.domain",
156 .permList = {
157 {
158 .permissionName = "ohos.permission.test",
159 .bundleName = "ohos.test.demo2",
160 .grantMode = 1,
161 .availableLevel = APL_NORMAL,
162 .label = "label",
163 .labelId = 1,
164 .description = "test2",
165 .descriptionId = 1
166 }
167 },
168 .permStateList = {
169 {
170 .permissionName = "ohos.permission.test",
171 .isGeneral = true,
172 .resDeviceID = { "local" },
173 .grantStatus = { PermissionState::PERMISSION_GRANTED },
174 .grantFlags = { 1 }
175 }
176 }
177 };
178 auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
179 SetSelfTokenID(tokenID.tokenIDEx);
180 }
181
SetHapToken1()182 void UdmfClientTest::SetHapToken1()
183 {
184 auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo1", INST_INDEX);
185 SetSelfTokenID(tokenId);
186 }
187
SetHapToken2()188 void UdmfClientTest::SetHapToken2()
189 {
190 auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo2", INST_INDEX);
191 SetSelfTokenID(tokenId);
192 }
193
AddPrivilege(QueryOption & option)194 void UdmfClientTest::AddPrivilege(QueryOption &option)
195 {
196 Privilege privilege;
197 privilege.tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo2", INST_INDEX);
198 privilege.readPermission = "readPermission";
199 privilege.writePermission = "writePermission";
200 SetNativeToken("msdp_sa");
201 auto status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
202 ASSERT_EQ(status, E_OK);
203 }
204
CompareDetails(const UDDetails & details)205 void UdmfClientTest::CompareDetails(const UDDetails &details)
206 {
207 for (const auto &detail : details) {
208 auto key = detail.first;
209 EXPECT_EQ(key, "udmf_key");
210 auto value = detail.second;
211 auto str = std::get<std::string>(value);
212 EXPECT_EQ(str, "udmf_value");
213 }
214 }
215
GetEmptyData(QueryOption & option)216 void UdmfClientTest::GetEmptyData(QueryOption &option)
217 {
218 UnifiedData data;
219 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
220 auto status = UdmfClient::GetInstance().GetData(option, data);
221 EXPECT_EQ(status, E_NOT_FOUND);
222 }
223
224 /**
225 * @tc.name: SetData001
226 * @tc.desc: Set data with invalid params
227 * @tc.type: FUNC
228 */
229 HWTEST_F(UdmfClientTest, SetData001, TestSize.Level1)
230 {
231 LOG_INFO(UDMF_TEST, "SetData001 begin.");
232
233 CustomOption option = { .intention = Intention::UD_INTENTION_DRAG };
234 UnifiedData data;
235 std::string key;
236 auto status = UdmfClient::GetInstance().SetData(option, data, key);
237 EXPECT_EQ(status, E_INVALID_PARAMETERS);
238
239 option = { .intention = Intention::UD_INTENTION_BUTT };
240 auto text = std::make_shared<Text>();
241 UDDetails details;
242 details.insert({ "udmf_key", "udmf_value" });
243 text->SetDetails(details);
244 data.AddRecord(text);
245 status = UdmfClient::GetInstance().SetData(option, data, key);
246 EXPECT_EQ(status, E_INVALID_PARAMETERS);
247
248 option = {};
249 status = UdmfClient::GetInstance().SetData(option, data, key);
250 EXPECT_EQ(status, E_INVALID_PARAMETERS);
251
252 option = { .intention = Intention::UD_INTENTION_BASE };
253 status = UdmfClient::GetInstance().SetData(option, data, key);
254 EXPECT_EQ(status, E_INVALID_PARAMETERS);
255 LOG_INFO(UDMF_TEST, "SetData001 end.");
256 }
257
258 /**
259 * @tc.name: SetData002
260 * @tc.desc: Set Text record with valid params and get data
261 * @tc.type: FUNC
262 */
263 HWTEST_F(UdmfClientTest, SetData002, TestSize.Level1)
264 {
265 LOG_INFO(UDMF_TEST, "SetData002 begin.");
266
267 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
268 UnifiedData data1;
269 auto text1 = std::make_shared<Text>();
270 UDDetails details1;
271 details1.insert({ "udmf_key", "udmf_value" });
272 text1->SetDetails(details1);
273 data1.AddRecord(text1);
274 std::string key;
275 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
276 ASSERT_EQ(status, E_OK);
277
278 QueryOption option2 = { .key = key };
279 AddPrivilege(option2);
280 SetHapToken2();
281 UnifiedData data2;
282 status = UdmfClient::GetInstance().GetData(option2, data2);
283 ASSERT_EQ(status, E_OK);
284
285 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
286 ASSERT_NE(record2, nullptr);
287 auto type = record2->GetType();
288 EXPECT_EQ(type, UDType::TEXT);
289
290 auto text2 = static_cast<Text *>(record2.get());
291 ASSERT_NE(text2, nullptr);
292 CompareDetails(text2->GetDetails());
293
294 GetEmptyData(option2);
295
296 LOG_INFO(UDMF_TEST, "SetData002 end.");
297 }
298
299 /**
300 * @tc.name: SetData003
301 * @tc.desc: Set PlainText record with valid params and get data
302 * @tc.type: FUNC
303 */
304 HWTEST_F(UdmfClientTest, SetData003, TestSize.Level1)
305 {
306 LOG_INFO(UDMF_TEST, "SetData003 begin.");
307
308 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
309 UnifiedData data1;
310 auto plainText1 = std::make_shared<PlainText>();
311 UDDetails details1;
312 details1.insert({ "udmf_key", "udmf_value" });
313 plainText1->SetDetails(details1);
314 plainText1->SetContent("content");
315 plainText1->SetAbstract("abstract");
316 data1.AddRecord(plainText1);
317 std::string key;
318 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
319 ASSERT_EQ(status, E_OK);
320
321 QueryOption option2 = { .key = key };
322 AddPrivilege(option2);
323 SetHapToken2();
324 UnifiedData data2;
325 status = UdmfClient::GetInstance().GetData(option2, data2);
326 ASSERT_EQ(status, E_OK);
327
328 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
329 ASSERT_NE(record2, nullptr);
330 auto type = record2->GetType();
331 ASSERT_EQ(type, UDType::PLAIN_TEXT);
332
333 auto text2 = static_cast<Text *>(record2.get());
334 ASSERT_NE(text2, nullptr);
335 CompareDetails(text2->GetDetails());
336
337 auto plainText2 = static_cast<PlainText *>(record2.get());
338 ASSERT_NE(plainText2, nullptr);
339 EXPECT_EQ(plainText1->GetContent(), plainText2->GetContent());
340 EXPECT_EQ(plainText1->GetAbstract(), plainText2->GetAbstract());
341
342 GetEmptyData(option2);
343
344 LOG_INFO(UDMF_TEST, "SetData003 end.");
345 }
346
347 /**
348 * @tc.name: SetData004
349 * @tc.desc: Set Html record with valid params and get data
350 * @tc.type: FUNC
351 */
352 HWTEST_F(UdmfClientTest, SetData004, TestSize.Level1)
353 {
354 LOG_INFO(UDMF_TEST, "SetData004 begin.");
355
356 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
357 UnifiedData data1;
358 std::string key;
359 auto html1 = std::make_shared<Html>();
360 UDDetails details1;
361 details1.insert({ "udmf_key", "udmf_value" });
362 html1->SetDetails(details1);
363 html1->SetHtmlContent("htmlcontent");
364 html1->SetPlainContent("plainContent");
365 data1.AddRecord(html1);
366 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
367 ASSERT_EQ(status, E_OK);
368
369 QueryOption option2 = { .key = key };
370 AddPrivilege(option2);
371 SetHapToken2();
372 UnifiedData data2;
373 status = UdmfClient::GetInstance().GetData(option2, data2);
374 ASSERT_EQ(status, E_OK);
375
376 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
377 ASSERT_NE(record2, nullptr);
378 auto type = record2->GetType();
379 ASSERT_EQ(type, UDType::HTML);
380
381 auto text2 = static_cast<Text *>(record2.get());
382 ASSERT_NE(text2, nullptr);
383 CompareDetails(text2->GetDetails());
384
385 auto html2 = static_cast<Html *>(record2.get());
386 ASSERT_NE(html2, nullptr);
387 EXPECT_EQ(html1->GetHtmlContent(), html2->GetHtmlContent());
388 EXPECT_EQ(html1->GetPlainContent(), html2->GetPlainContent());
389
390 GetEmptyData(option2);
391
392 LOG_INFO(UDMF_TEST, "SetData004 end.");
393 }
394
395 /**
396 * @tc.name: SetData005
397 * @tc.desc: Set Link record with valid params and get data
398 * @tc.type: FUNC
399 */
400 HWTEST_F(UdmfClientTest, SetData005, TestSize.Level1)
401 {
402 LOG_INFO(UDMF_TEST, "SetData005 begin.");
403
404 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
405 UnifiedData data1;
406 std::string key;
407 auto link1 = std::make_shared<Link>();
408 UDDetails details1;
409 details1.insert({ "udmf_key", "udmf_value" });
410 link1->SetDetails(details1);
411 link1->SetUrl("url");
412 link1->SetDescription("description");
413 data1.AddRecord(link1);
414 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
415 ASSERT_EQ(status, E_OK);
416
417 QueryOption option2 = { .key = key };
418 AddPrivilege(option2);
419 SetHapToken2();
420 UnifiedData data2;
421 status = UdmfClient::GetInstance().GetData(option2, data2);
422 ASSERT_EQ(status, E_OK);
423
424 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
425 ASSERT_NE(record2, nullptr);
426 auto type = record2->GetType();
427 ASSERT_EQ(type, UDType::HYPERLINK);
428
429 auto text2 = static_cast<Text *>(record2.get());
430 ASSERT_NE(text2, nullptr);
431 CompareDetails(text2->GetDetails());
432
433 auto link2 = static_cast<Link *>(record2.get());
434 ASSERT_NE(link2, nullptr);
435 EXPECT_EQ(link1->GetUrl(), link2->GetUrl());
436 EXPECT_EQ(link1->GetDescription(), link2->GetDescription());
437
438 GetEmptyData(option2);
439
440 LOG_INFO(UDMF_TEST, "SetData005 end.");
441 }
442
443 /**
444 * @tc.name: SetData006
445 * @tc.desc: Set File record with valid params and get data
446 * @tc.type: FUNC
447 */
448 HWTEST_F(UdmfClientTest, SetData006, TestSize.Level1)
449 {
450 LOG_INFO(UDMF_TEST, "SetData006 begin.");
451
452 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
453 UnifiedData data1;
454 std::string key;
455 auto file1 = std::make_shared<File>();
456 file1->SetRemoteUri("remoteUri");
457 UDDetails details1;
458 details1.insert({ "udmf_key", "udmf_value" });
459 file1->SetDetails(details1);
460 data1.AddRecord(file1);
461 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
462 ASSERT_EQ(status, E_OK);
463
464 QueryOption option2 = { .key = key };
465 AddPrivilege(option2);
466 SetHapToken2();
467 UnifiedData data2;
468 status = UdmfClient::GetInstance().GetData(option2, data2);
469 ASSERT_EQ(status, E_OK);
470
471 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
472 ASSERT_NE(record2, nullptr);
473 auto type = record2->GetType();
474 ASSERT_EQ(type, UDType::FILE);
475
476 auto file2 = static_cast<File *>(record2.get());
477 ASSERT_NE(file2, nullptr);
478 EXPECT_EQ(file1->GetRemoteUri(), file2->GetRemoteUri());
479 CompareDetails(file2->GetDetails());
480
481 GetEmptyData(option2);
482
483 LOG_INFO(UDMF_TEST, "SetData006 end.");
484 }
485
486 /**
487 * @tc.name: SetData007
488 * @tc.desc: Set Image record with valid params and get data
489 * @tc.type: FUNC
490 */
491 HWTEST_F(UdmfClientTest, SetData007, TestSize.Level1)
492 {
493 LOG_INFO(UDMF_TEST, "SetData007 begin.");
494
495 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
496 UnifiedData data1;
497 std::string key;
498 auto image1 = std::make_shared<Image>();
499 UDDetails details1;
500 details1.insert({ "udmf_key", "udmf_value" });
501 image1->SetDetails(details1);
502 image1->SetRemoteUri("remoteUri");
503 data1.AddRecord(image1);
504 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
505 ASSERT_EQ(status, E_OK);
506
507 QueryOption option2 = { .key = key };
508 AddPrivilege(option2);
509 SetHapToken2();
510 UnifiedData data2;
511 status = UdmfClient::GetInstance().GetData(option2, data2);
512 ASSERT_EQ(status, E_OK);
513
514 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
515 ASSERT_NE(record2, nullptr);
516 auto type = record2->GetType();
517 ASSERT_EQ(type, UDType::IMAGE);
518
519 auto file2 = static_cast<File *>(record2.get());
520 ASSERT_NE(file2, nullptr);
521 CompareDetails(file2->GetDetails());
522
523 auto image2 = static_cast<Image *>(record2.get());
524 ASSERT_NE(image2, nullptr);
525 EXPECT_EQ(image1->GetRemoteUri(), image2->GetRemoteUri());
526
527 GetEmptyData(option2);
528
529 LOG_INFO(UDMF_TEST, "SetData007 end.");
530 }
531
532 /**
533 * @tc.name: SetData008
534 * @tc.desc: Set Video record with valid params and get data
535 * @tc.type: FUNC
536 */
537 HWTEST_F(UdmfClientTest, SetData008, TestSize.Level1)
538 {
539 LOG_INFO(UDMF_TEST, "SetData008 begin.");
540
541 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
542 UnifiedData data1;
543 std::string key;
544 auto video1 = std::make_shared<Video>();
545 UDDetails details1;
546 details1.insert({ "udmf_key", "udmf_value" });
547 video1->SetDetails(details1);
548 video1->SetRemoteUri("remoteUri");
549 data1.AddRecord(video1);
550 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
551 ASSERT_EQ(status, E_OK);
552
553 QueryOption option2 = { .key = key };
554 AddPrivilege(option2);
555 SetHapToken2();
556 UnifiedData data2;
557 status = UdmfClient::GetInstance().GetData(option2, data2);
558 ASSERT_EQ(status, E_OK);
559
560 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
561 ASSERT_NE(record2, nullptr);
562 auto type = record2->GetType();
563 EXPECT_EQ(type, UDType::VIDEO);
564
565 auto file2 = static_cast<File *>(record2.get());
566 ASSERT_NE(file2, nullptr);
567 CompareDetails(file2->GetDetails());
568
569 auto video2 = static_cast<Video *>(record2.get());
570 ASSERT_NE(video2, nullptr);
571 EXPECT_EQ(video1->GetRemoteUri(), video2->GetRemoteUri());
572
573 GetEmptyData(option2);
574
575 LOG_INFO(UDMF_TEST, "SetData008 end.");
576 }
577
578 /**
579 * @tc.name: SetData009
580 * @tc.desc: Set Audio record with valid params and get data
581 * @tc.type: FUNC
582 */
583 HWTEST_F(UdmfClientTest, SetData009, TestSize.Level1)
584 {
585 LOG_INFO(UDMF_TEST, "SetData009 begin.");
586
587 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
588 UnifiedData data1;
589 std::string key;
590 auto audio1 = std::make_shared<Audio>();
591 UDDetails details1;
592 details1.insert({ "udmf_key", "udmf_value" });
593 audio1->SetDetails(details1);
594 audio1->SetRemoteUri("remoteUri");
595 data1.AddRecord(audio1);
596 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
597 ASSERT_EQ(status, E_OK);
598
599 QueryOption option2 = { .key = key };
600 AddPrivilege(option2);
601 SetHapToken2();
602 UnifiedData data2;
603 status = UdmfClient::GetInstance().GetData(option2, data2);
604 ASSERT_EQ(status, E_OK);
605
606 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
607 ASSERT_NE(record2, nullptr);
608 auto type = record2->GetType();
609 EXPECT_EQ(type, UDType::AUDIO);
610
611 auto file2 = static_cast<File *>(record2.get());
612 ASSERT_NE(file2, nullptr);
613 CompareDetails(file2->GetDetails());
614
615 auto audio2 = static_cast<Audio *>(record2.get());
616 ASSERT_NE(audio2, nullptr);
617 EXPECT_EQ(audio1->GetRemoteUri(), audio2->GetRemoteUri());
618
619 GetEmptyData(option2);
620
621 LOG_INFO(UDMF_TEST, "SetData009 end.");
622 }
623
624 /**
625 * @tc.name: SetData010
626 * @tc.desc: Set Folder record with valid params and get data
627 * @tc.type: FUNC
628 */
629 HWTEST_F(UdmfClientTest, SetData010, TestSize.Level1)
630 {
631 LOG_INFO(UDMF_TEST, "SetData010 begin.");
632
633 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
634 UnifiedData data1;
635 std::string key;
636 auto folder1 = std::make_shared<Folder>();
637 UDDetails details1;
638 details1.insert({ "udmf_key", "udmf_value" });
639 folder1->SetDetails(details1);
640 folder1->SetRemoteUri("remoteUri");
641 data1.AddRecord(folder1);
642 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
643 ASSERT_EQ(status, E_OK);
644
645 QueryOption option2 = { .key = key };
646 AddPrivilege(option2);
647 SetHapToken2();
648 UnifiedData data2;
649 status = UdmfClient::GetInstance().GetData(option2, data2);
650 ASSERT_EQ(status, E_OK);
651
652 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
653 ASSERT_NE(record2, nullptr);
654 auto type = record2->GetType();
655 EXPECT_EQ(type, UDType::FOLDER);
656
657 auto file2 = static_cast<File *>(record2.get());
658 ASSERT_NE(file2, nullptr);
659 CompareDetails(file2->GetDetails());
660
661 auto folder2 = static_cast<Folder *>(record2.get());
662 ASSERT_NE(folder2, nullptr);
663 EXPECT_EQ(folder1->GetRemoteUri(), folder2->GetRemoteUri());
664
665 GetEmptyData(option2);
666
667 LOG_INFO(UDMF_TEST, "SetData010 end.");
668 }
669
670 /**
671 * @tc.name: SetData011
672 * @tc.desc: Set SystemDefined record with valid params and get data
673 * @tc.type: FUNC
674 */
675 HWTEST_F(UdmfClientTest, SetData011, TestSize.Level1)
676 {
677 LOG_INFO(UDMF_TEST, "SetData011 begin.");
678
679 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
680 UnifiedData data1;
681 std::string key;
682 auto systemDefinedRecord1 = std::make_shared<SystemDefinedRecord>();
683 UDDetails details1;
684 details1.insert({ "udmf_key", "udmf_value" });
685 systemDefinedRecord1->SetDetails(details1);
686 data1.AddRecord(systemDefinedRecord1);
687 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
688 ASSERT_EQ(status, E_OK);
689
690 QueryOption option2 = { .key = key };
691 AddPrivilege(option2);
692 SetHapToken2();
693 UnifiedData data2;
694 status = UdmfClient::GetInstance().GetData(option2, data2);
695 ASSERT_EQ(status, E_OK);
696
697 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
698 ASSERT_NE(record2, nullptr);
699 auto type = record2->GetType();
700 ASSERT_EQ(type, UDType::SYSTEM_DEFINED_RECORD);
701
702 auto systemDefinedRecord2 = static_cast<SystemDefinedRecord *>(record2.get());
703 ASSERT_NE(systemDefinedRecord2, nullptr);
704 CompareDetails(systemDefinedRecord2->GetDetails());
705
706 GetEmptyData(option2);
707
708 LOG_INFO(UDMF_TEST, "SetData011 end.");
709 }
710
711 /**
712 * @tc.name: SetData012
713 * @tc.desc: Set Form record with valid params and get data
714 * @tc.type: FUNC
715 */
716 HWTEST_F(UdmfClientTest, SetData012, TestSize.Level1)
717 {
718 LOG_INFO(UDMF_TEST, "SetData012 begin.");
719
720 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
721 UnifiedData data1;
722 std::string key;
723 auto systemDefinedForm1 = std::make_shared<SystemDefinedForm>();
724 UDDetails details1;
725 details1.insert({ "udmf_key", "udmf_value" });
726 systemDefinedForm1->SetDetails(details1);
727 systemDefinedForm1->SetFormId(123);
728 systemDefinedForm1->SetFormName("formName");
729 systemDefinedForm1->SetModule("module");
730 systemDefinedForm1->SetAbilityName("abilityName");
731 systemDefinedForm1->SetBundleName("bundleName");
732 data1.AddRecord(systemDefinedForm1);
733 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
734 ASSERT_EQ(status, E_OK);
735
736 QueryOption option2 = { .key = key };
737 AddPrivilege(option2);
738 SetHapToken2();
739 UnifiedData data2;
740 status = UdmfClient::GetInstance().GetData(option2, data2);
741 ASSERT_EQ(status, E_OK);
742
743 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
744 ASSERT_NE(record2, nullptr);
745 auto type = record2->GetType();
746 ASSERT_EQ(type, UDType::SYSTEM_DEFINED_FORM);
747
748 auto systemDefinedRecord2 = static_cast<SystemDefinedRecord *>(record2.get());
749 ASSERT_NE(systemDefinedRecord2, nullptr);
750 CompareDetails(systemDefinedRecord2->GetDetails());
751
752 auto systemDefinedForm2 = static_cast<SystemDefinedForm *>(record2.get());
753 ASSERT_NE(systemDefinedForm2, nullptr);
754 EXPECT_EQ(systemDefinedForm1->GetFormId(), systemDefinedForm2->GetFormId());
755 EXPECT_EQ(systemDefinedForm1->GetFormName(), systemDefinedForm2->GetFormName());
756 EXPECT_EQ(systemDefinedForm1->GetBundleName(), systemDefinedForm2->GetBundleName());
757 EXPECT_EQ(systemDefinedForm1->GetAbilityName(), systemDefinedForm2->GetAbilityName());
758 EXPECT_EQ(systemDefinedForm1->GetModule(), systemDefinedForm2->GetModule());
759
760 GetEmptyData(option2);
761
762 LOG_INFO(UDMF_TEST, "SetData012 end.");
763 }
764
765 /**
766 * @tc.name: SetData013
767 * @tc.desc: Set AppItem record with valid params and get data
768 * @tc.type: FUNC
769 */
770 HWTEST_F(UdmfClientTest, SetData013, TestSize.Level1)
771 {
772 LOG_INFO(UDMF_TEST, "SetData013 begin.");
773
774 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
775 UnifiedData data1;
776 std::string key;
777 auto systemDefinedAppItem1 = std::make_shared<SystemDefinedAppItem>();
778 UDDetails details1;
779 details1.insert({ "udmf_key", "udmf_value" });
780 systemDefinedAppItem1->SetDetails(details1);
781 systemDefinedAppItem1->SetAppId("appId");
782 systemDefinedAppItem1->SetAppName("appName");
783 systemDefinedAppItem1->SetAppIconId("appIconId");
784 systemDefinedAppItem1->SetAppLabelId("appLabelId");
785 systemDefinedAppItem1->SetBundleName("bundleName");
786 systemDefinedAppItem1->SetAbilityName("abilityName");
787 data1.AddRecord(systemDefinedAppItem1);
788 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
789 ASSERT_EQ(status, E_OK);
790
791 QueryOption option2 = { .key = key };
792 AddPrivilege(option2);
793 SetHapToken2();
794 UnifiedData data2;
795 status = UdmfClient::GetInstance().GetData(option2, data2);
796 ASSERT_EQ(status, E_OK);
797
798 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
799 ASSERT_NE(record2, nullptr);
800 auto type = record2->GetType();
801 ASSERT_EQ(type, UDType::SYSTEM_DEFINED_APP_ITEM);
802
803 auto systemDefinedRecord2 = static_cast<SystemDefinedRecord *>(record2.get());
804 ASSERT_NE(systemDefinedRecord2, nullptr);
805 CompareDetails(systemDefinedRecord2->GetDetails());
806
807 auto systemDefinedAppItem2 = static_cast<SystemDefinedAppItem *>(record2.get());
808 ASSERT_NE(systemDefinedAppItem2, nullptr);
809 EXPECT_EQ(systemDefinedAppItem1->GetAppId(), systemDefinedAppItem2->GetAppId());
810 EXPECT_EQ(systemDefinedAppItem1->GetAppName(), systemDefinedAppItem2->GetAppName());
811 EXPECT_EQ(systemDefinedAppItem1->GetBundleName(), systemDefinedAppItem2->GetBundleName());
812 EXPECT_EQ(systemDefinedAppItem1->GetAbilityName(), systemDefinedAppItem2->GetAbilityName());
813 EXPECT_EQ(systemDefinedAppItem1->GetAppIconId(), systemDefinedAppItem2->GetAppIconId());
814 EXPECT_EQ(systemDefinedAppItem1->GetAppLabelId(), systemDefinedAppItem2->GetAppLabelId());
815
816 GetEmptyData(option2);
817
818 LOG_INFO(UDMF_TEST, "SetData013 end.");
819 }
820
821 /**
822 * @tc.name: SetData014
823 * @tc.desc: Set PixelMap record with valid params and get data
824 * @tc.type: FUNC
825 */
826 HWTEST_F(UdmfClientTest, SetData014, TestSize.Level1)
827 {
828 LOG_INFO(UDMF_TEST, "SetData014 begin.");
829
830 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
831 UnifiedData data1;
832 std::string key;
833 auto systemDefinedPixelMap1 = std::make_shared<SystemDefinedPixelMap>();
834 UDDetails details1;
835 details1.insert({ "udmf_key", "udmf_value" });
836 systemDefinedPixelMap1->SetDetails(details1);
837 std::vector<uint8_t> rawData1;
838
839 uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
840 OHOS::Media::InitializationOptions opts = { { 5, 7 },
841 Media::PixelFormat::ARGB_8888,
842 Media::PixelFormat::ARGB_8888 };
843 std::unique_ptr<OHOS::Media::PixelMap> pixelMap =
844 OHOS::Media::PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
845 std::shared_ptr<OHOS::Media::PixelMap> pixelMapIn = move(pixelMap);
846 pixelMapIn->EncodeTlv(rawData1);
847
848 systemDefinedPixelMap1->SetRawData(rawData1);
849 data1.AddRecord(systemDefinedPixelMap1);
850 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
851 ASSERT_EQ(status, E_OK);
852
853 QueryOption option2 = { .key = key };
854 AddPrivilege(option2);
855 SetHapToken2();
856 UnifiedData data2;
857 status = UdmfClient::GetInstance().GetData(option2, data2);
858 ASSERT_EQ(status, E_OK);
859
860 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
861 ASSERT_NE(record2, nullptr);
862 auto type = record2->GetType();
863 ASSERT_EQ(type, UDType::SYSTEM_DEFINED_PIXEL_MAP);
864
865 auto systemDefinedRecord2 = static_cast<SystemDefinedRecord *>(record2.get());
866 ASSERT_NE(systemDefinedRecord2, nullptr);
867 CompareDetails(systemDefinedRecord2->GetDetails());
868
869 auto systemDefinedPixelMap2 = static_cast<SystemDefinedPixelMap *>(record2.get());
870 ASSERT_NE(systemDefinedPixelMap2, nullptr);
871 auto rawData2 = systemDefinedPixelMap2->GetRawData();
872 EXPECT_EQ(rawData1.size(), rawData2.size());
873 for (uint32_t i = 0; i < rawData1.size(); ++i) {
874 EXPECT_EQ(rawData1[i], rawData2[i]);
875 }
876
877 GetEmptyData(option2);
878
879 LOG_INFO(UDMF_TEST, "SetData014 end.");
880 }
881
882 /**
883 * @tc.name: SetData015
884 * @tc.desc: Set Application Defined record with valid params and get data
885 * @tc.type: FUNC
886 */
887 HWTEST_F(UdmfClientTest, SetData015, TestSize.Level1)
888 {
889 LOG_INFO(UDMF_TEST, "SetData015 begin.");
890
891 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
892 UnifiedData data1;
893 std::string key;
894 auto applicationDefinedRecord1 = std::make_shared<ApplicationDefinedRecord>();
895 applicationDefinedRecord1->SetApplicationDefinedType("applicationDefinedType");
896 std::vector<uint8_t> rawData1 = { 1, 2, 3, 4, 5 };
897 applicationDefinedRecord1->SetRawData(rawData1);
898 data1.AddRecord(applicationDefinedRecord1);
899 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
900 ASSERT_EQ(status, E_OK);
901
902 QueryOption option2 = { .key = key };
903 AddPrivilege(option2);
904 SetHapToken2();
905 UnifiedData data2;
906 status = UdmfClient::GetInstance().GetData(option2, data2);
907 ASSERT_EQ(status, E_OK);
908
909 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
910 ASSERT_NE(record2, nullptr);
911 auto type = record2->GetType();
912 ASSERT_EQ(type, UDType::APPLICATION_DEFINED_RECORD);
913
914 auto applicationDefinedRecord2 = static_cast<ApplicationDefinedRecord *>(record2.get());
915 ASSERT_NE(applicationDefinedRecord2, nullptr);
916 EXPECT_EQ(applicationDefinedRecord1->GetApplicationDefinedType(),
917 applicationDefinedRecord2->GetApplicationDefinedType());
918 auto rawData2 = applicationDefinedRecord2->GetRawData();
919 EXPECT_EQ(rawData1.size(), rawData2.size());
920 for (uint32_t i = 0; i < rawData1.size(); ++i) {
921 EXPECT_EQ(rawData1[i], rawData2[i]);
922 }
923
924 GetEmptyData(option2);
925
926 LOG_INFO(UDMF_TEST, "SetData015 end.");
927 }
928
929 /**
930 * @tc.name: SetData016
931 * @tc.desc: Set multiple record with valid params and get data
932 * @tc.type: FUNC
933 */
934 HWTEST_F(UdmfClientTest, SetData016, TestSize.Level1)
935 {
936 LOG_INFO(UDMF_TEST, "SetData016 begin.");
937
938 CustomOption customOption = {.intention = Intention::UD_INTENTION_DRAG};
939 std::string key;
940 UnifiedData inputData;
941 std::vector<std::shared_ptr<UnifiedRecord>> inputRecords = {
942 std::make_shared<Text>(),
943 std::make_shared<PlainText>(),
944 std::make_shared<File>(),
945 std::make_shared<Image>(),
946 std::make_shared<SystemDefinedRecord>(),
947 std::make_shared<SystemDefinedForm>(),
948 std::make_shared<ApplicationDefinedRecord>()
949 };
950 inputData.SetRecords(inputRecords);
951
952 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
953 ASSERT_EQ(status, E_OK);
954
955 QueryOption queryOption = { .key = key };
956 UnifiedData outputData;
957 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
958 ASSERT_EQ(status, E_OK);
959 auto outputRecords = outputData.GetRecords();
960 ASSERT_EQ(inputRecords.size(), outputRecords.size());
961 for (size_t i = 0; i < outputRecords.size(); ++i) {
962 ASSERT_EQ(outputRecords[i]->GetType(), inputRecords[i]->GetType());
963 }
964
965 LOG_INFO(UDMF_TEST, "SetData016 end.");
966 }
967
968 /**
969 * @tc.name: SetData017
970 * @tc.desc: Set 512 records with valid params and get data
971 * @tc.type: FUNC
972 */
973 HWTEST_F(UdmfClientTest, SetData017, TestSize.Level1)
974 {
975 LOG_INFO(UDMF_TEST, "SetData017 begin.");
976
977 CustomOption customOption = {.intention = Intention::UD_INTENTION_DRAG};
978 std::string key;
979 UnifiedData inputData;
980 std::vector<std::shared_ptr<UnifiedRecord>> inputRecords;
981 for (int32_t i = 0; i < 512; ++i) {
982 inputRecords.emplace_back(std::make_shared<Text>());
983 }
984 inputData.SetRecords(inputRecords);
985
986 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
987 ASSERT_EQ(status, E_OK);
988
989 QueryOption queryOption = { .key = key };
990 UnifiedData outputData;
991 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
992 ASSERT_EQ(status, E_OK);
993 auto outputRecords = outputData.GetRecords();
994 ASSERT_EQ(inputRecords.size(), outputRecords.size());
995
996 LOG_INFO(UDMF_TEST, "SetData017 end.");
997 }
998
999 /**
1000 * @tc.name: SetData018
1001 * @tc.desc: Set one 2MB record of data with valid params and get data
1002 * @tc.type: FUNC
1003 */
1004 HWTEST_F(UdmfClientTest, SetData018, TestSize.Level1)
1005 {
1006 LOG_INFO(UDMF_TEST, "SetData018 begin.");
1007
1008 CustomOption customOption = { .intention = Intention::UD_INTENTION_DRAG };
1009 UnifiedData inputData;
1010 std::string key;
1011 UDDetails details;
1012 std::string value;
1013 int64_t maxSize = 512 * 1024;
1014 for (int64_t i = 0; i < maxSize; ++i) {
1015 value += "11";
1016 }
1017 details.insert({ value, value });
1018 auto text = std::make_shared<Text>();
1019 text->SetDetails(details);
1020 inputData.AddRecord(text);
1021
1022 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
1023 ASSERT_EQ(status, E_OK);
1024
1025 QueryOption queryOption = { .key = key };
1026 UnifiedData outputData;
1027 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
1028 ASSERT_EQ(status, E_OK);
1029
1030 LOG_INFO(UDMF_TEST, "SetData018 end.");
1031 }
1032
1033 /**
1034 * @tc.name: SetData019
1035 * @tc.desc: Set one over 2MB record of data with valid params and get data
1036 * @tc.type: FUNC
1037 */
1038 HWTEST_F(UdmfClientTest, SetData019, TestSize.Level1)
1039 {
1040 LOG_INFO(UDMF_TEST, "SetData019 begin.");
1041
1042 CustomOption customOption = { .intention = Intention::UD_INTENTION_DRAG };
1043 UnifiedData inputData;
1044 std::string key;
1045 UDDetails details;
1046 std::string value;
1047 int64_t maxSize = 512 * 1024;
1048 for (int64_t i = 0; i < maxSize; ++i) {
1049 value += "11";
1050 }
1051 details.insert({ value, value });
1052 details.insert({ "udmf_key", "udmf_value" });
1053 auto text = std::make_shared<Text>();
1054 text->SetDetails(details);
1055 inputData.AddRecord(text);
1056
1057 UnifiedDataHelper::SetRootPath("/data/udmf_test/");
1058 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
1059 ASSERT_EQ(status, E_OK);
1060
1061 QueryOption queryOption = { .key = key };
1062 UnifiedData outputData;
1063 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
1064 ASSERT_EQ(status, E_OK);
1065 UnifiedDataHelper::SetRootPath("");
1066
1067 LOG_INFO(UDMF_TEST, "SetData019 end.");
1068 }
1069
1070 /**
1071 * @tc.name: SetData020
1072 * @tc.desc: Set two 2MB record of data with valid params and get data
1073 * @tc.type: FUNC
1074 */
1075 HWTEST_F(UdmfClientTest, SetData020, TestSize.Level1)
1076 {
1077 LOG_INFO(UDMF_TEST, "SetData020 begin.");
1078
1079 CustomOption customOption = { .intention = Intention::UD_INTENTION_DRAG };
1080 UnifiedData inputData;
1081 std::string key;
1082 UDDetails details;
1083 std::string value;
1084 int64_t maxSize = 512 * 1024;
1085 for (int64_t i = 0; i < maxSize; ++i) {
1086 value += "11";
1087 }
1088 details.insert({ value, value });
1089 auto text = std::make_shared<Text>();
1090 text->SetDetails(details);
1091 for (int i = 0; i < 2; ++i) {
1092 inputData.AddRecord(text);
1093 }
1094 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
1095 ASSERT_EQ(status, E_OK);
1096
1097 QueryOption queryOption = { .key = key };
1098 UnifiedData outputData;
1099 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
1100 ASSERT_EQ(status, E_OK);
1101
1102 LOG_INFO(UDMF_TEST, "SetData020 end.");
1103 }
1104
1105 /**
1106 * @tc.name: GetData001
1107 * @tc.desc: Get data with invalid key
1108 * @tc.type: FUNC
1109 */
1110 HWTEST_F(UdmfClientTest, GetData001, TestSize.Level1)
1111 {
1112 LOG_INFO(UDMF_TEST, "GetData001 begin.");
1113
1114 QueryOption option;
1115 UnifiedData data;
1116 auto status = UdmfClient::GetInstance().GetData(option, data);
1117 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1118
1119 option.key = "udmf";
1120 status = UdmfClient::GetInstance().GetData(option, data);
1121 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1122
1123 option.key = "odmf://";
1124 status = UdmfClient::GetInstance().GetData(option, data);
1125 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1126
1127 option.key = "udmf://drag";
1128 status = UdmfClient::GetInstance().GetData(option, data);
1129 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1130
1131 option.key = "udmf://123/bundle/group";
1132 status = UdmfClient::GetInstance().GetData(option, data);
1133 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1134
1135 option.key = "udmf://drag/bundle";
1136 status = UdmfClient::GetInstance().GetData(option, data);
1137 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1138
1139 option.key = "udmf://drag/bundle***/group";
1140 status = UdmfClient::GetInstance().GetData(option, data);
1141 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1142
1143 option.key = "udmf://drag/bundle/";
1144 status = UdmfClient::GetInstance().GetData(option, data);
1145 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1146
1147 option.key = "udmf://drag/bundle/group###";
1148 status = UdmfClient::GetInstance().GetData(option, data);
1149 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1150
1151 LOG_INFO(UDMF_TEST, "GetData001 end.");
1152 }
1153
1154 /**
1155 * @tc.name: GetSummary001
1156 * @tc.desc: Get summary data
1157 * @tc.type: FUNC
1158 */
1159 HWTEST_F(UdmfClientTest, GetSummary001, TestSize.Level1)
1160 {
1161 LOG_INFO(UDMF_TEST, "GetSummary001 begin.");
1162
1163 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
1164 UnifiedData data;
1165 std::string key;
1166
1167 UDDetails details;
1168 details.insert({ "udmf_key", "udmf_value" });
1169
1170 auto text = std::make_shared<Text>();
1171 text->SetDetails(details);
1172 data.AddRecord(text);
1173
1174 auto plainText = std::make_shared<PlainText>();
1175 plainText->SetDetails(details);
1176 plainText->SetContent("content");
1177 plainText->SetAbstract("abstract");
1178 data.AddRecord(plainText);
1179
1180 auto file = std::make_shared<File>();
1181 file->SetDetails(details);
1182 file->SetUri("uri");
1183 file->SetRemoteUri("remoteUri");
1184 data.AddRecord(file);
1185
1186 auto image = std::make_shared<Image>();
1187 file->SetDetails(details);
1188 image->SetUri("uri");
1189 image->SetRemoteUri("remoteUri");
1190 data.AddRecord(image);
1191
1192 auto systemDefinedRecord = std::make_shared<SystemDefinedRecord>();
1193 systemDefinedRecord->SetDetails(details);
1194 data.AddRecord(systemDefinedRecord);
1195
1196 auto systemDefinedForm = std::make_shared<SystemDefinedForm>();
1197 systemDefinedForm->SetDetails(details);
1198 systemDefinedForm->SetFormId(123);
1199 systemDefinedForm->SetFormName("formName");
1200 systemDefinedForm->SetModule("module");
1201 systemDefinedForm->SetAbilityName("abilityName");
1202 systemDefinedForm->SetBundleName("bundleName");
1203 data.AddRecord(systemDefinedForm);
1204
1205 auto applicationDefinedRecord = std::make_shared<ApplicationDefinedRecord>();
1206 applicationDefinedRecord->SetApplicationDefinedType("applicationDefinedType");
1207 std::vector<uint8_t> rawData = { 1, 2, 3, 4, 5 };
1208 applicationDefinedRecord->SetRawData(rawData);
1209 data.AddRecord(applicationDefinedRecord);
1210
1211 std::shared_ptr<Object> obj = std::make_shared<Object>();
1212 obj->value_[UNIFORM_DATA_TYPE] = "general.file-uri";
1213 obj->value_[FILE_URI_PARAM] = "http://demo.com";
1214 obj->value_[FILE_TYPE] = "abcdefg";
1215 auto record8 = std::make_shared<UnifiedRecord>(FILE_URI, obj);
1216 data.AddRecord(record8);
1217
1218 auto record9 = std::make_shared<UnifiedRecord>(PNG, "http://demo.com");
1219 data.AddRecord(record9);
1220 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
1221 ASSERT_EQ(status, E_OK);
1222
1223 QueryOption option2 = { .key = key };
1224 Summary summary;
1225 status = UdmfClient::GetInstance().GetSummary(option2, summary);
1226
1227 auto size = text->GetSize();
1228 size += plainText->GetSize();
1229 size += file->GetSize();
1230 size += image->GetSize();
1231 size += systemDefinedRecord->GetSize();
1232 size += systemDefinedForm->GetSize();
1233 size += applicationDefinedRecord->GetSize();
1234 size += record8->GetSize();
1235 size += record9->GetSize();
1236
1237 EXPECT_EQ(status, E_OK);
1238 EXPECT_EQ(summary.totalSize, size);
1239 EXPECT_EQ(summary.summary["general.text"], text->GetSize());
1240 EXPECT_EQ(summary.summary["general.plain-text"], plainText->GetSize());
1241 EXPECT_EQ(summary.summary["general.file"], file->GetSize());
1242 EXPECT_EQ(summary.summary["general.image"], image->GetSize());
1243 EXPECT_EQ(summary.summary["SystemDefinedType"], systemDefinedRecord->GetSize());
1244 EXPECT_EQ(summary.summary["openharmony.form"], systemDefinedForm->GetSize());
1245 EXPECT_EQ(summary.summary["ApplicationDefinedType"], applicationDefinedRecord->GetSize());
1246 EXPECT_EQ(summary.summary["general.file-uri"], record8->GetSize());
1247 EXPECT_EQ(summary.summary["general.png"], record9->GetSize());
1248
1249 LOG_INFO(UDMF_TEST, "GetSummary001 end.");
1250 }
1251
1252
1253 /**
1254 * @tc.name: GetSummary002
1255 * @tc.desc: Get summary with invalid key
1256 * @tc.type: FUNC
1257 */
1258 HWTEST_F(UdmfClientTest, GetSummary002, TestSize.Level1)
1259 {
1260 LOG_INFO(UDMF_FRAMEWORK, "GetSummary002 begin.");
1261
1262 QueryOption option;
1263 Summary summary;
1264 auto status = UdmfClient::GetInstance().GetSummary(option, summary);
1265 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1266
1267 option.key = "udmf";
1268 status = UdmfClient::GetInstance().GetSummary(option, summary);
1269 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1270
1271 option.key = "odmf://";
1272 status = UdmfClient::GetInstance().GetSummary(option, summary);
1273 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1274
1275 option.key = "udmf://drag";
1276 status = UdmfClient::GetInstance().GetSummary(option, summary);
1277 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1278
1279 option.key = "udmf://123/bundle/group";
1280 status = UdmfClient::GetInstance().GetSummary(option, summary);
1281 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1282
1283 option.key = "udmf://drag/bundle";
1284 status = UdmfClient::GetInstance().GetSummary(option, summary);
1285 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1286
1287 option.key = "udmf://drag/bundle***/group";
1288 status = UdmfClient::GetInstance().GetSummary(option, summary);
1289 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1290
1291 option.key = "udmf://drag/bundle/";
1292 status = UdmfClient::GetInstance().GetSummary(option, summary);
1293 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1294
1295 option.key = "udmf://drag/bundle/group###";
1296 status = UdmfClient::GetInstance().GetSummary(option, summary);
1297 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1298
1299 LOG_INFO(UDMF_FRAMEWORK, "GetSummary002 end.");
1300 }
1301
1302 /**
1303 * @tc.name: AddPrivilege001
1304 * @tc.desc: Add privilege with valid params
1305 * @tc.type: FUNC
1306 */
1307 HWTEST_F(UdmfClientTest, AddPrivilege001, TestSize.Level1)
1308 {
1309 LOG_INFO(UDMF_TEST, "AddPrivilege001 begin.");
1310
1311 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
1312 UnifiedData data;
1313 auto text = std::make_shared<Text>();
1314 UDDetails details;
1315 details.insert({ "udmf_key", "udmf_value" });
1316 text->SetDetails(details);
1317 data.AddRecord(text);
1318 std::string key;
1319 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
1320 ASSERT_EQ(status, E_OK);
1321
1322 QueryOption option2 = { .key = key };
1323 Privilege privilege;
1324 SetHapToken2();
1325 privilege.tokenId = AccessTokenKit::GetHapTokenID(100, "ohos.test.demo2", 0);
1326 privilege.readPermission = "readPermission";
1327 privilege.writePermission = "writePermission";
1328 SetNativeToken("msdp_sa");
1329 status = UdmfClient::GetInstance().AddPrivilege(option2, privilege);
1330 ASSERT_EQ(status, E_OK);
1331
1332 LOG_INFO(UDMF_TEST, "AddPrivilege001 end.");
1333 }
1334
1335 /**
1336 * @tc.name: AddPrivilege002
1337 * @tc.desc: Add Privilege with invalid params
1338 * @tc.type: FUNC
1339 */
1340 HWTEST_F(UdmfClientTest, AddPrivilege002, TestSize.Level1)
1341 {
1342 LOG_INFO(UDMF_FRAMEWORK, "AddPrivilege002 begin.");
1343
1344 QueryOption option;
1345 Privilege privilege;
1346 auto status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1347 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1348
1349 option.key = "udmf";
1350 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1351 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1352
1353 option.key = "odmf://";
1354 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1355 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1356
1357 option.key = "udmf://drag";
1358 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1359 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1360
1361 option.key = "udmf://123/bundle/group";
1362 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1363 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1364
1365 option.key = "udmf://drag/bundle";
1366 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1367 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1368
1369 option.key = "udmf://drag/bundle***/group";
1370 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1371 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1372
1373 option.key = "udmf://drag/bundle/";
1374 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1375 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1376
1377 option.key = "udmf://drag/bundle/group###";
1378 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1379 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1380
1381 LOG_INFO(UDMF_FRAMEWORK, "AddPrivilege002 end.");
1382 }
1383
1384 /**
1385 * @tc.name: AddPrivilege003
1386 * @tc.desc: Add privilege with invalid intention
1387 * @tc.type: FUNC
1388 */
1389 HWTEST_F(UdmfClientTest, AddPrivilege003, TestSize.Level1)
1390 {
1391 LOG_INFO(UDMF_TEST, "AddPrivilege003 begin.");
1392
1393 CustomOption option1 = { .intention = Intention::UD_INTENTION_DATA_HUB };
1394 UnifiedData data;
1395 auto text = std::make_shared<Text>();
1396 UDDetails details;
1397 details.insert({ "udmf_key", "udmf_value" });
1398 text->SetDetails(details);
1399 data.AddRecord(text);
1400 std::string key;
1401 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
1402 ASSERT_EQ(status, E_OK);
1403
1404 QueryOption option2 = { .key = key };
1405 Privilege privilege;
1406 SetHapToken2();
1407 privilege.tokenId = AccessTokenKit::GetHapTokenID(100, "ohos.test.demo2", 0);
1408 privilege.readPermission = "readPermission";
1409 privilege.writePermission = "writePermission";
1410 SetNativeToken("msdp_sa");
1411 status = UdmfClient::GetInstance().AddPrivilege(option2, privilege);
1412 ASSERT_EQ(status, E_NO_PERMISSION);
1413 LOG_INFO(UDMF_TEST, "AddPrivilege003 end.");
1414 }
1415
1416 /**
1417 * @tc.name: AddPrivilege004
1418 * @tc.desc: Add privilege for unauthorized process with valid params
1419 * @tc.type: FUNC
1420 */
1421 HWTEST_F(UdmfClientTest, AddPrivilege004, TestSize.Level1)
1422 {
1423 LOG_INFO(UDMF_TEST, "AddPrivilege004 begin.");
1424
1425 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
1426 UnifiedData data;
1427 auto text = std::make_shared<Text>();
1428 UDDetails details;
1429 details.insert({ "udmf_key", "udmf_value" });
1430 text->SetDetails(details);
1431 data.AddRecord(text);
1432 std::string key;
1433 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
1434 ASSERT_EQ(status, E_OK);
1435
1436 QueryOption option2 = { .key = key };
1437 Privilege privilege;
1438 SetHapToken2();
1439 privilege.tokenId = AccessTokenKit::GetHapTokenID(100, "ohos.test.demo2", 0);
1440 privilege.readPermission = "readPermission";
1441 privilege.writePermission = "writePermission";
1442 SetNativeToken("foundation");
1443 status = UdmfClient::GetInstance().AddPrivilege(option2, privilege);
1444 ASSERT_EQ(status, E_NO_PERMISSION);
1445 LOG_INFO(UDMF_TEST, "AddPrivilege004 end.");
1446 }
1447
1448 /**
1449 * @tc.name: AddPrivilege005
1450 * @tc.desc: Add privilege with valid params
1451 * @tc.type: FUNC
1452 */
1453 HWTEST_F(UdmfClientTest, AddPrivilege005, TestSize.Level1)
1454 {
1455 LOG_INFO(UDMF_TEST, "AddPrivilege005 begin.");
1456
1457 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
1458 UnifiedData data;
1459 auto text = std::make_shared<Text>();
1460 UDDetails details;
1461 details.insert({ "udmf_key", "udmf_value" });
1462 text->SetDetails(details);
1463 data.AddRecord(text);
1464 std::string key;
1465 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
1466 ASSERT_EQ(status, E_OK);
1467
1468 QueryOption option2 = { .key = key };
1469 Privilege privilege;
1470 SetHapToken2();
1471 privilege.tokenId = AccessTokenKit::GetHapTokenID(100, "ohos.test.demo2", 0);
1472 privilege.readPermission = "readAndKeep";
1473 privilege.writePermission = "writePermission";
1474 SetNativeToken("msdp_sa");
1475 status = UdmfClient::GetInstance().AddPrivilege(option2, privilege);
1476 ASSERT_EQ(status, E_OK);
1477
1478 SetHapToken2();
1479 UnifiedData data1;
1480 status = UdmfClient::GetInstance().GetData(option2, data1);
1481 ASSERT_EQ(status, E_OK);
1482
1483 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
1484 UnifiedData data2;
1485 status = UdmfClient::GetInstance().GetData(option2, data2);
1486 ASSERT_EQ(status, E_OK);
1487 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
1488 ASSERT_NE(record2, nullptr);
1489 auto type = record2->GetType();
1490 ASSERT_EQ(type, UDType::TEXT);
1491 auto text2 = static_cast<Text *>(record2.get());
1492 ASSERT_NE(text2, nullptr);
1493 CompareDetails(text2->GetDetails()); // Can be read repeatedly.
1494 LOG_INFO(UDMF_TEST, "AddPrivilege005 end.");
1495 }
1496
1497 /**
1498 * @tc.name: GetSelfData001
1499 * @tc.desc: Set File record with valid params and no add privilege and get data by self
1500 * @tc.type: FUNC
1501 */
1502 HWTEST_F(UdmfClientTest, GetSelfData001, TestSize.Level1)
1503 {
1504 LOG_INFO(UDMF_TEST, "GetSelfData001 begin.");
1505
1506 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
1507 UnifiedData data1;
1508 std::string key;
1509 auto file1 = std::make_shared<File>();
1510 file1->SetRemoteUri("remoteUri");
1511 UDDetails details1;
1512 details1.insert({ "udmf_key", "udmf_value" });
1513 file1->SetDetails(details1);
1514 data1.AddRecord(file1);
1515 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
1516 ASSERT_EQ(status, E_OK);
1517
1518 QueryOption option2 = { .key = key };
1519 UnifiedData data2;
1520 status = UdmfClient::GetInstance().GetData(option2, data2);
1521 ASSERT_EQ(status, E_OK);
1522
1523 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
1524 ASSERT_NE(record2, nullptr);
1525 auto type = record2->GetType();
1526 ASSERT_EQ(type, UDType::FILE);
1527
1528 auto file2 = static_cast<File *>(record2.get());
1529 ASSERT_NE(file2, nullptr);
1530 EXPECT_EQ(file1->GetRemoteUri(), file2->GetRemoteUri());
1531 CompareDetails(file2->GetDetails());
1532
1533 GetEmptyData(option2);
1534
1535 LOG_INFO(UDMF_TEST, "GetSelfData001 end.");
1536 }
1537
1538 /**
1539 * @tc.name: GetSelfData002
1540 * @tc.desc: Set File record with valid params and add privilege and get data by self
1541 * @tc.type: FUNC
1542 */
1543 HWTEST_F(UdmfClientTest, GetSelfData002, TestSize.Level1)
1544 {
1545 LOG_INFO(UDMF_TEST, "GetSelfData002 begin.");
1546
1547 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
1548 UnifiedData data1;
1549 std::string key;
1550 auto file1 = std::make_shared<File>();
1551 file1->SetRemoteUri("remoteUri");
1552 UDDetails details1;
1553 details1.insert({ "udmf_key", "udmf_value" });
1554 file1->SetDetails(details1);
1555 data1.AddRecord(file1);
1556 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
1557 ASSERT_EQ(status, E_OK);
1558
1559 QueryOption option2 = { .key = key };
1560 AddPrivilege(option2);
1561 SetHapToken1();
1562 UnifiedData data2;
1563 status = UdmfClient::GetInstance().GetData(option2, data2);
1564 ASSERT_EQ(status, E_OK);
1565
1566 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
1567 ASSERT_NE(record2, nullptr);
1568 auto type = record2->GetType();
1569 ASSERT_EQ(type, UDType::FILE);
1570
1571 auto file2 = static_cast<File *>(record2.get());
1572 ASSERT_NE(file2, nullptr);
1573 EXPECT_EQ(file1->GetRemoteUri(), file2->GetRemoteUri());
1574 CompareDetails(file2->GetDetails());
1575
1576 GetEmptyData(option2);
1577
1578 LOG_INFO(UDMF_TEST, "GetSelfData002 end.");
1579 }
1580
1581 /**
1582 * @tc.name: SetData021
1583 * @tc.desc: Set datas with intention ${UD_INTENTION_DATA_HUB} and manually check db is cleared before set or not
1584 * @tc.type: FUNC
1585 */
1586 HWTEST_F(UdmfClientTest, SetData021, TestSize.Level1)
1587 {
1588 LOG_INFO(UDMF_TEST, "SetData021 begin.");
1589 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
1590 std::vector<UnifiedData> unifiedDataSet;
1591 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
1592 ASSERT_EQ(status, E_OK);
1593 unifiedDataSet.clear();
1594 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
1595 ASSERT_EQ(status, E_OK);
1596 ASSERT_TRUE(unifiedDataSet.empty());
1597
1598 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
1599 UnifiedData data1;
1600 auto plainText1 = std::make_shared<PlainText>();
1601 plainText1->SetContent("content1");
1602 data1.AddRecord(plainText1);
1603 std::string key;
1604 status = UdmfClient::GetInstance().SetData(customOption, data1, key);
1605 ASSERT_EQ(status, E_OK);
1606 UnifiedData data2;
1607 plainText1->SetContent("content2");
1608 data2.AddRecord(plainText1);
1609 status = UdmfClient::GetInstance().SetData(customOption, data2, key);
1610 ASSERT_EQ(status, E_OK);
1611
1612 SetHapToken2();
1613 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
1614 ASSERT_EQ(status, E_OK);
1615 auto size = static_cast<int32_t>(unifiedDataSet.size());
1616 ASSERT_EQ(size, 2);
1617 LOG_INFO(UDMF_TEST, "SetData021 end.");
1618 }
1619
1620 /**
1621 * @tc.name: UpdateData001
1622 * @tc.desc: Update data with invalid params
1623 * @tc.type: FUNC
1624 */
1625 HWTEST_F(UdmfClientTest, UpdateData001, TestSize.Level1)
1626 {
1627 LOG_INFO(UDMF_TEST, "UpdateData001 begin.");
1628
1629 UnifiedData data;
1630 QueryOption queryOption = { .key = "" };
1631 auto status = UdmfClient::GetInstance().UpdateData(queryOption, data);
1632 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1633
1634 queryOption = { .key = "udmf://drag/ohos.test.demo1/abcde" };
1635 status = UdmfClient::GetInstance().UpdateData(queryOption, data);
1636 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1637
1638 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
1639 UnifiedData data1;
1640 auto plainText1 = std::make_shared<PlainText>();
1641 plainText1->SetContent("content1");
1642 data1.AddRecord(plainText1);
1643 std::string key;
1644 status = UdmfClient::GetInstance().SetData(customOption, data1, key);
1645 ASSERT_EQ(status, E_OK);
1646
1647 queryOption = { .key = key };
1648 SetHapToken2();
1649 status = UdmfClient::GetInstance().UpdateData(queryOption, data);
1650 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1651 LOG_INFO(UDMF_TEST, "UpdateData001 end.");
1652 }
1653
1654 /**
1655 * @tc.name: UpdateData002
1656 * @tc.desc: Update data with valid params
1657 * @tc.type: FUNC
1658 */
1659 HWTEST_F(UdmfClientTest, UpdateData002, TestSize.Level1)
1660 {
1661 LOG_INFO(UDMF_TEST, "UpdateData002 begin.");
1662
1663 UnifiedData data;
1664 auto plainText = std::make_shared<PlainText>();
1665 plainText->SetContent("content");
1666 data.AddRecord(plainText);
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 auto status = UdmfClient::GetInstance().SetData(customOption, data1, key);
1675
1676 ASSERT_EQ(status, E_OK);
1677 QueryOption queryOption = { .key = key };
1678 SetHapToken2();
1679 status = UdmfClient::GetInstance().UpdateData(queryOption, data);
1680 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1681
1682 SetHapToken1();
1683 status = UdmfClient::GetInstance().UpdateData(queryOption, data);
1684 ASSERT_EQ(status, E_OK);
1685
1686 std::vector<UnifiedData> dataSet;
1687 status = UdmfClient::GetInstance().GetBatchData(queryOption, dataSet);
1688 std::shared_ptr<UnifiedRecord> record2 = dataSet[0].GetRecordAt(0);
1689 ASSERT_NE(record2, nullptr);
1690 auto type = record2->GetType();
1691 ASSERT_EQ(type, UDType::PLAIN_TEXT);
1692 auto plainText2 = static_cast<PlainText *>(record2.get());
1693 ASSERT_EQ(plainText2->GetContent(), "content");
1694
1695 LOG_INFO(UDMF_TEST, "UpdateData002 end.");
1696 }
1697
1698 /**
1699 * @tc.name: QueryData001
1700 * @tc.desc: Query data with invalid params
1701 * @tc.type: FUNC
1702 */
1703 HWTEST_F(UdmfClientTest, QueryData001, TestSize.Level1)
1704 {
1705 LOG_INFO(UDMF_TEST, "QueryData001 begin.");
1706 std::vector<UnifiedData> unifiedDataSet;
1707 QueryOption queryOption = {};
1708 auto status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1709 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1710
1711 queryOption = { .key = "udmf://drag/ohos.test.demo1/abcde" };
1712 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1713 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1714
1715 queryOption = { .intention = UD_INTENTION_DRAG };
1716 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1717 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1718
1719 queryOption = { .key = "udmf://DataHub/ohos.test.demo1/abcde", .intention = UD_INTENTION_DRAG };
1720 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1721 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1722
1723 queryOption = { .key = "udmf://drag/ohos.test.demo1/abcde", .intention = UD_INTENTION_DATA_HUB };
1724 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1725 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1726 LOG_INFO(UDMF_TEST, "QueryData001 end.");
1727 }
1728
1729 /**
1730 * @tc.name: QueryData002
1731 * @tc.desc: Query data with valid params
1732 * @tc.type: FUNC
1733 */
1734 HWTEST_F(UdmfClientTest, QueryData002, TestSize.Level1)
1735 {
1736 LOG_INFO(UDMF_TEST, "QueryData002 begin.");
1737
1738 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
1739 std::vector<UnifiedData> unifiedDataSet;
1740 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
1741 ASSERT_EQ(status, E_OK);
1742 unifiedDataSet.clear();
1743 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
1744 ASSERT_EQ(status, E_OK);
1745 ASSERT_TRUE(unifiedDataSet.empty());
1746
1747 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
1748 UnifiedData data;
1749 auto plainText = std::make_shared<PlainText>();
1750 plainText->SetContent("content1");
1751 data.AddRecord(plainText);
1752 std::string key;
1753 status = UdmfClient::GetInstance().SetData(customOption, data, key);
1754 ASSERT_EQ(status, E_OK);
1755
1756 query = { .key = key };
1757 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
1758 ASSERT_EQ(status, E_OK);
1759 auto size = static_cast<int32_t>(unifiedDataSet.size());
1760 ASSERT_EQ(size, 1);
1761 std::shared_ptr<UnifiedRecord> record2 = unifiedDataSet[0].GetRecordAt(0);
1762 ASSERT_NE(record2, nullptr);
1763 auto type = record2->GetType();
1764 ASSERT_EQ(type, UDType::PLAIN_TEXT);
1765 auto plainText2 = static_cast<PlainText *>(record2.get());
1766 ASSERT_EQ(plainText2->GetContent(), "content1");
1767
1768 UnifiedData data2;
1769 plainText = std::make_shared<PlainText>();
1770 plainText->SetContent("content2");
1771 data2.AddRecord(plainText);
1772 status = UdmfClient::GetInstance().SetData(customOption, data2, key);
1773 ASSERT_EQ(status, E_OK);
1774
1775 unifiedDataSet.clear();
1776 query = { .key = key, .intention = UD_INTENTION_DATA_HUB };
1777 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
1778 ASSERT_EQ(status, E_OK);
1779 size = static_cast<int32_t>(unifiedDataSet.size());
1780 ASSERT_EQ(size, 1);
1781 record2 = unifiedDataSet[0].GetRecordAt(0);
1782 ASSERT_NE(record2, nullptr);
1783 type = record2->GetType();
1784 ASSERT_EQ(type, UDType::PLAIN_TEXT);
1785 plainText2 = static_cast<PlainText *>(record2.get());
1786 ASSERT_EQ(plainText2->GetContent(), "content2");
1787
1788 unifiedDataSet.clear();
1789 query = { .intention = UD_INTENTION_DATA_HUB };
1790 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
1791 ASSERT_EQ(status, E_OK);
1792 size = static_cast<int32_t>(unifiedDataSet.size());
1793 ASSERT_EQ(size, 2);
1794
1795 LOG_INFO(UDMF_TEST, "QueryData002 end.");
1796 }
1797
1798 /**
1799 * @tc.name: DeleteData001
1800 * @tc.desc: Delete data with invalid params
1801 * @tc.type: FUNC
1802 */
1803 HWTEST_F(UdmfClientTest, DeleteData001, TestSize.Level1)
1804 {
1805 LOG_INFO(UDMF_TEST, "DeleteData001 begin.");
1806 std::vector<UnifiedData> unifiedDataSet;
1807 QueryOption queryOption = {};
1808 auto status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
1809 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1810
1811 queryOption = { .key = "udmf://drag/ohos.test.demo1/abcde" };
1812 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
1813 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1814
1815 queryOption = { .intention = UD_INTENTION_DRAG };
1816 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
1817 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1818
1819 queryOption = { .key = "udmf://DataHub/ohos.test.demo1/abcde", .intention = UD_INTENTION_DRAG };
1820 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
1821 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1822
1823 queryOption = { .key = "udmf://drag/ohos.test.demo1/abcde", .intention = UD_INTENTION_DATA_HUB };
1824 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
1825 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1826 LOG_INFO(UDMF_TEST, "DeleteData001 end.");
1827 }
1828
1829 /**
1830 * @tc.name: DeleteData002
1831 * @tc.desc: Delete data with valid params
1832 * @tc.type: FUNC
1833 */
1834 HWTEST_F(UdmfClientTest, DeleteData002, TestSize.Level1)
1835 {
1836 LOG_INFO(UDMF_TEST, "DeleteData002 begin.");
1837
1838 CustomOption customOption = { .intention = UD_INTENTION_DATA_HUB };
1839 UnifiedData data;
1840 auto plainText = std::make_shared<PlainText>();
1841 plainText->SetContent("content1");
1842 data.AddRecord(plainText);
1843 std::string key;
1844 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
1845 ASSERT_EQ(status, E_OK);
1846 status = UdmfClient::GetInstance().SetData(customOption, data, key);
1847 ASSERT_EQ(status, E_OK);
1848 status = UdmfClient::GetInstance().SetData(customOption, data, key);
1849 ASSERT_EQ(status, E_OK);
1850
1851 QueryOption queryOption = { .key = key };
1852 SetHapToken2();
1853
1854 std::vector<UnifiedData> unifiedDataSet;
1855 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
1856 ASSERT_EQ(status, E_OK);
1857 ASSERT_EQ(0, unifiedDataSet.size());
1858
1859 SetHapToken1();
1860 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
1861 ASSERT_EQ(status, E_OK);
1862 ASSERT_EQ(1, unifiedDataSet.size());
1863
1864 unifiedDataSet.clear();
1865 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1866 ASSERT_TRUE(unifiedDataSet.empty());
1867
1868 queryOption = { .intention = UD_INTENTION_DATA_HUB };
1869 unifiedDataSet.clear();
1870 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1871 ASSERT_TRUE(!unifiedDataSet.empty());
1872
1873 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
1874 ASSERT_EQ(status, E_OK);
1875
1876 unifiedDataSet.clear();
1877 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1878 ASSERT_TRUE(unifiedDataSet.empty());
1879 LOG_INFO(UDMF_TEST, "DeleteData002 end.");
1880 }
1881
1882 /**
1883 * @tc.name: SetData022
1884 * @tc.desc: Set two over 2MB record of data with valid params and get data
1885 * @tc.type: FUNC
1886 */
1887 HWTEST_F(UdmfClientTest, SetData022, TestSize.Level1)
1888 {
1889 LOG_INFO(UDMF_TEST, "SetData022 begin.");
1890
1891 CustomOption customOption = { .intention = Intention::UD_INTENTION_DRAG };
1892 UnifiedData inputData;
1893 std::string key;
1894 UDDetails details;
1895 std::string value;
1896 int64_t maxSize = 512 * 1024;
1897 for (int64_t i = 0; i < maxSize; ++i) {
1898 value += "11";
1899 }
1900 details.insert({ value, value });
1901 details.insert({ "udmf_key", "udmf_value" });
1902 auto text = std::make_shared<Text>();
1903 text->SetDetails(details);
1904 for (int i = 0; i < 2; ++i) {
1905 inputData.AddRecord(text);
1906 }
1907 UnifiedDataHelper::SetRootPath("/data/udmf_test/");
1908 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
1909 ASSERT_EQ(status, E_OK);
1910
1911 QueryOption queryOption = { .key = key };
1912 UnifiedData outputData;
1913 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
1914 ASSERT_EQ(status, E_OK);
1915 UnifiedDataHelper::SetRootPath("");
1916
1917 LOG_INFO(UDMF_TEST, "SetData022 end.");
1918 }
1919
1920 /**
1921 * @tc.name: SetData023
1922 * @tc.desc: Set 200MB record of data with valid params and get data
1923 * @tc.type: FUNC
1924 */
1925 HWTEST_F(UdmfClientTest, SetData023, TestSize.Level1)
1926 {
1927 LOG_INFO(UDMF_TEST, "SetData023 begin.");
1928
1929 CustomOption customOption = { .intention = Intention::UD_INTENTION_DRAG };
1930 UnifiedData inputData;
1931 std::string key;
1932 UDDetails details;
1933 std::string value;
1934 int64_t maxSize = 512 * 1024;
1935 for (int64_t i = 0; i < maxSize; ++i) {
1936 value += "11";
1937 }
1938 details.insert({ value, value });
1939 Text text;
1940 text.SetDetails(details);
1941 for (int64_t i = 0; i < 100; ++i) {
1942 auto record = std::make_shared<Text>();
1943 inputData.AddRecord(record);
1944 }
1945 auto records = inputData.GetRecords();
1946 LOG_INFO(UDMF_TEST, "SetData023 inputData.size() = %{public}zu", records.size());
1947 UnifiedDataHelper::SetRootPath("/data/udmf_test/");
1948 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
1949 ASSERT_EQ(status, E_OK);
1950
1951 QueryOption queryOption = { .key = key };
1952 UnifiedData outputData;
1953 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
1954 ASSERT_EQ(status, E_OK);
1955 UnifiedDataHelper::SetRootPath("");
1956
1957 LOG_INFO(UDMF_TEST, "SetData023 end.");
1958 }
1959
1960 /**
1961 * @tc.name: SetData024
1962 * @tc.desc: Set over 200MB record of data with valid params and get data
1963 * @tc.type: FUNC
1964 */
1965 HWTEST_F(UdmfClientTest, SetData024, TestSize.Level1)
1966 {
1967 LOG_INFO(UDMF_TEST, "SetData024 begin.");
1968
1969 CustomOption customOption = { .intention = Intention::UD_INTENTION_DRAG };
1970 UnifiedData inputData;
1971 std::string key;
1972 UDDetails details;
1973 std::string value;
1974 int64_t maxSize = 512 * 1024;
1975 for (int64_t i = 0; i < maxSize; ++i) {
1976 value += "11";
1977 }
1978 details.insert({ value, value });
1979 auto text = std::make_shared<Text>();
1980 text->SetDetails(details);
1981 for (int64_t i = 0; i < 101; ++i) {
1982 inputData.AddRecord(text);
1983 }
1984 auto records = inputData.GetRecords();
1985 LOG_INFO(UDMF_TEST, "SetData024 inputData.size() = %{public}zu", records.size());
1986
1987 UnifiedDataHelper::SetRootPath("/data/udmf_test/");
1988 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
1989 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1990 UnifiedDataHelper::SetRootPath("");
1991
1992 LOG_INFO(UDMF_TEST, "SetData024 end.");
1993 }
1994
1995 /**
1996 * @tc.name: SetData025
1997 * @tc.desc: Set PixelMap record with valid params and get data
1998 * @tc.type: FUNC
1999 */
2000 HWTEST_F(UdmfClientTest, SetData025, TestSize.Level1)
2001 {
2002 LOG_INFO(UDMF_TEST, "SetData025 begin.");
2003
2004 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2005 UnifiedData data1;
2006 std::string key;
2007 auto systemDefinedPixelMap1 = std::make_shared<SystemDefinedPixelMap>();
2008 UDDetails details1;
2009 details1.insert({ "udmf_key", "udmf_value" });
2010 systemDefinedPixelMap1->SetDetails(details1);
2011 std::vector<uint8_t> rawData1 = { 1, 2, 3, 4, 5 };
2012
2013 systemDefinedPixelMap1->SetRawData(rawData1);
2014 data1.AddRecord(systemDefinedPixelMap1);
2015 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
2016 ASSERT_EQ(status, E_OK);
2017
2018 QueryOption option2 = { .key = key };
2019 AddPrivilege(option2);
2020 SetHapToken2();
2021 UnifiedData data2;
2022 status = UdmfClient::GetInstance().GetData(option2, data2);
2023 ASSERT_EQ(status, E_OK);
2024
2025 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
2026 ASSERT_NE(record2, nullptr);
2027 auto type = record2->GetType();
2028 ASSERT_EQ(type, UDType::SYSTEM_DEFINED_PIXEL_MAP);
2029
2030 auto systemDefinedRecord2 = static_cast<SystemDefinedRecord *>(record2.get());
2031 ASSERT_NE(systemDefinedRecord2, nullptr);
2032 CompareDetails(systemDefinedRecord2->GetDetails());
2033
2034 auto systemDefinedPixelMap2 = static_cast<SystemDefinedPixelMap *>(record2.get());
2035 ASSERT_NE(systemDefinedPixelMap2, nullptr);
2036 auto rawData2 = systemDefinedPixelMap2->GetRawData();
2037 EXPECT_EQ(rawData1.size(), rawData2.size());
2038 for (uint32_t i = 0; i < rawData1.size(); ++i) {
2039 EXPECT_EQ(rawData1[i], rawData2[i]);
2040 }
2041
2042 LOG_INFO(UDMF_TEST, "SetData025 end.");
2043 }
2044
2045 /**
2046 * @tc.name: SetData026
2047 * @tc.desc: Set more record with valid params and get data
2048 * @tc.type: FUNC
2049 */
2050 HWTEST_F(UdmfClientTest, SetData026, TestSize.Level1)
2051 {
2052 LOG_INFO(UDMF_TEST, "SetData026 begin.");
2053
2054 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2055 UnifiedData data1;
2056 std::string key;
2057 auto systemDefinedPixelMap1 = std::make_shared<SystemDefinedPixelMap>();
2058 UDDetails details1;
2059 details1.insert({ "udmf_key", "udmf_value" });
2060 systemDefinedPixelMap1->SetDetails(details1);
2061 std::vector<uint8_t> rawData1 = { 1, 2, 3, 4, 5 };
2062
2063 systemDefinedPixelMap1->SetRawData(rawData1);
2064 std::shared_ptr<UnifiedRecord> record2 = std::make_shared<PlainText>(UDType::PLAIN_TEXT, "this is a content");
2065 data1.AddRecord(systemDefinedPixelMap1);
2066 data1.AddRecord(record2);
2067 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
2068 ASSERT_EQ(status, E_OK);
2069
2070 QueryOption option2 = { .key = key };
2071 AddPrivilege(option2);
2072 SetHapToken2();
2073 UnifiedData data2;
2074 status = UdmfClient::GetInstance().GetData(option2, data2);
2075 ASSERT_EQ(status, E_OK);
2076
2077 std::shared_ptr<UnifiedRecord> record3 = data2.GetRecordAt(0);
2078 ASSERT_NE(record3, nullptr);
2079 auto type = record3->GetType();
2080 ASSERT_EQ(type, UDType::SYSTEM_DEFINED_PIXEL_MAP);
2081
2082 auto systemDefinedRecord2 = static_cast<SystemDefinedRecord *>(record3.get());
2083 ASSERT_NE(systemDefinedRecord2, nullptr);
2084 CompareDetails(systemDefinedRecord2->GetDetails());
2085
2086 auto systemDefinedPixelMap2 = static_cast<SystemDefinedPixelMap *>(record3.get());
2087 ASSERT_NE(systemDefinedPixelMap2, nullptr);
2088 auto rawData2 = systemDefinedPixelMap2->GetRawData();
2089 EXPECT_EQ(rawData1.size(), rawData2.size());
2090 for (uint32_t i = 0; i < rawData1.size(); ++i) {
2091 EXPECT_EQ(rawData1[i], rawData2[i]);
2092 }
2093
2094 std::shared_ptr<UnifiedRecord> record4 = data2.GetRecordAt(1);
2095 auto plainText = static_cast<PlainText *>(record4.get());
2096 ASSERT_EQ(UDType::PLAIN_TEXT, plainText->GetType());
2097 ASSERT_EQ("this is a content", plainText->GetContent());
2098
2099 LOG_INFO(UDMF_TEST, "SetData026 end.");
2100 }
2101
2102 /**
2103 * @tc.name: GetSummary003
2104 * @tc.desc: Get summary data
2105 * @tc.type: FUNC
2106 */
2107 HWTEST_F(UdmfClientTest, GetSummary003, TestSize.Level1)
2108 {
2109 LOG_INFO(UDMF_TEST, "GetSummary003 begin.");
2110
2111 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2112 UnifiedData data;
2113 std::string key;
2114
2115 UDDetails details;
2116 details.insert({ "udmf_key", "udmf_value" });
2117 std::string value;
2118 int64_t maxSize = 512 * 1024;
2119 for (int64_t i = 0; i < maxSize; ++i) {
2120 value += "11";
2121 }
2122 details.insert({ value, value });
2123
2124 auto text = std::make_shared<Text>();
2125 text->SetDetails(details);
2126 data.AddRecord(text);
2127
2128 auto plainText = std::make_shared<PlainText>();
2129 plainText->SetDetails(details);
2130 plainText->SetContent("content");
2131 plainText->SetAbstract("abstract");
2132 data.AddRecord(plainText);
2133
2134 UnifiedDataHelper::SetRootPath("/data/udmf_test/");
2135 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
2136 ASSERT_EQ(status, E_OK);
2137 UnifiedDataHelper::SetRootPath("");
2138
2139 QueryOption option2 = { .key = key };
2140 Summary summary;
2141 status = UdmfClient::GetInstance().GetSummary(option2, summary);
2142
2143 auto size = text->GetSize();
2144 size += plainText->GetSize();
2145
2146 ASSERT_EQ(status, E_OK);
2147 ASSERT_EQ(summary.totalSize, size);
2148 ASSERT_EQ(summary.summary["general.text"], text->GetSize());
2149 ASSERT_EQ(summary.summary["general.plain-text"], plainText->GetSize());
2150
2151 LOG_INFO(UDMF_TEST, "GetSummary003 end.");
2152 }
2153
2154 /**
2155 * @tc.name: IsRemoteData
2156 * @tc.desc: is remote data, result false: not remote data, true: remote data.
2157 * @tc.type: FUNC
2158 */
2159 HWTEST_F(UdmfClientTest, IsRemoteData001, TestSize.Level1)
2160 {
2161 LOG_INFO(UDMF_TEST, "IsRemoteData001 begin.");
2162
2163 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2164 UnifiedData data;
2165 std::string key;
2166
2167 UDDetails details;
2168 details.insert({ "udmf_key", "udmf_value" });
2169
2170 auto text = std::make_shared<Text>();
2171 text->SetDetails(details);
2172 data.AddRecord(text);
2173
2174 auto plainText = std::make_shared<PlainText>();
2175 plainText->SetDetails(details);
2176 plainText->SetContent("content");
2177 plainText->SetAbstract("abstract");
2178 data.AddRecord(plainText);
2179
2180 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
2181 ASSERT_EQ(status, E_OK);
2182
2183 QueryOption option2 = { .key = key };
2184 bool result = true;
2185 status = UdmfClient::GetInstance().IsRemoteData(option2, result);
2186
2187 ASSERT_EQ(status, E_OK);
2188 ASSERT_EQ(result, false);
2189
2190 LOG_INFO(UDMF_TEST, "IsRemoteData001 end.");
2191 }
2192
2193 /**
2194 * @tc.name: GetTypesLabels001
2195 * @tc.desc: test GetTypesLabels
2196 * @tc.type: FUNC
2197 */
2198 HWTEST_F(UdmfClientTest, GetTypesLabels001, TestSize.Level1)
2199 {
2200 LOG_INFO(UDMF_TEST, "GetTypesLabels001 begin.");
2201 UnifiedData data;
2202 UDDetails details;
2203 details.insert({ "udmf_key", "udmf_value" });
2204 auto text = std::make_shared<Text>();
2205 text->SetDetails(details);
2206 auto plainText = std::make_shared<PlainText>();
2207 plainText->SetDetails(details);
2208 std::vector<std::shared_ptr<UnifiedRecord>> records = {text, plainText};
2209 data.AddRecords(records);
2210
2211 std::vector<std::string> types = {"general.text", "general.plain-text"};
2212 ASSERT_EQ(data.GetTypesLabels(), types);
2213 ASSERT_EQ(data.HasType("general.text"), true);
2214 ASSERT_EQ(data.HasType("general.plain-text"), true);
2215 ASSERT_EQ(data.HasType("general.html"), false);
2216 }
2217
2218 /**
2219 * @tc.name: QueryUDSData001
2220 * @tc.desc: QueryUDSData001
2221 * @tc.type: FUNC
2222 */
2223 HWTEST_F(UdmfClientTest, QueryUDSData001, TestSize.Level1)
2224 {
2225 LOG_INFO(UDMF_TEST, "QueryUDSData001 begin.");
2226
2227 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
2228 std::vector<UnifiedData> unifiedDataSet;
2229 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
2230 ASSERT_EQ(status, E_OK);
2231 unifiedDataSet.clear();
2232 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
2233 ASSERT_EQ(status, E_OK);
2234 ASSERT_TRUE(unifiedDataSet.empty());
2235
2236 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
2237 UnifiedData data;
2238 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<PlainText>(UDType::PLAIN_TEXT, "plainTextContent");
2239 data.AddRecord(record1);
2240 std::string key;
2241 status = UdmfClient::GetInstance().SetData(customOption, data, key);
2242 ASSERT_EQ(status, E_OK);
2243
2244 query = { .key = key };
2245 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
2246 ASSERT_EQ(status, E_OK);
2247 ASSERT_EQ(unifiedDataSet.size(), 1);
2248 std::shared_ptr<UnifiedRecord> record2 = unifiedDataSet[0].GetRecordAt(0);
2249 ASSERT_NE(record2, nullptr);
2250 ASSERT_EQ(record2->GetType(), UDType::PLAIN_TEXT);
2251 ValueType value = record2->GetValue();
2252 ASSERT_NE(std::get_if<std::string>(&value), nullptr);
2253 ASSERT_EQ(std::get<std::string>(value), "plainTextContent");
2254 LOG_INFO(UDMF_TEST, "QueryUDSData001 end.");
2255 }
2256
2257 /**
2258 * @tc.name: QueryUDSData002
2259 * @tc.desc: QueryUDSData002
2260 * @tc.type: FUNC
2261 */
2262 HWTEST_F(UdmfClientTest, QueryUDSData002, TestSize.Level1)
2263 {
2264 LOG_INFO(UDMF_TEST, "QueryUDSData002 begin.");
2265
2266 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
2267 std::vector<UnifiedData> unifiedDataSet;
2268 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
2269 ASSERT_EQ(status, E_OK);
2270 unifiedDataSet.clear();
2271 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
2272 ASSERT_EQ(status, E_OK);
2273 ASSERT_TRUE(unifiedDataSet.empty());
2274
2275 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
2276 UnifiedData data;
2277 auto obj = std::make_shared<Object>();
2278 obj->value_["uniformDataType"] = "general.plain-text";
2279 obj->value_["textContent"] = "plainTextContent";
2280 obj->value_["abstract"] = "plainTextAbstract";
2281 auto obj2 = std::make_shared<Object>();
2282 obj2->value_["detail1"] = "detail1";
2283 obj2->value_["detail2"] = "detail2";
2284 obj->value_["details"] = obj2;
2285 auto record = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
2286 data.AddRecord(record);
2287 std::string key;
2288 status = UdmfClient::GetInstance().SetData(customOption, data, key);
2289 ASSERT_EQ(status, E_OK);
2290
2291 unifiedDataSet.clear();
2292 query = { .key = key, .intention = UD_INTENTION_DATA_HUB };
2293 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
2294 ASSERT_EQ(status, E_OK);
2295 ASSERT_EQ(unifiedDataSet.size(), 1);
2296 auto record2 = unifiedDataSet[0].GetRecordAt(0);
2297 ASSERT_NE(record2, nullptr);
2298 ASSERT_EQ(record2->GetType(), UDType::PLAIN_TEXT);
2299 auto value = record2->GetValue();
2300
2301 ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&value), nullptr);
2302 obj = std::get<std::shared_ptr<Object>>(value);
2303
2304 ASSERT_NE(std::get_if<std::string>(&obj->value_["uniformDataType"]), nullptr);
2305 ASSERT_EQ(std::get<std::string>(obj->value_["uniformDataType"]), "general.plain-text");
2306 ASSERT_NE(std::get_if<std::string>(&obj->value_["textContent"]), nullptr);
2307 ASSERT_EQ(std::get<std::string>(obj->value_["textContent"]), "plainTextContent");
2308 ASSERT_NE(std::get_if<std::string>(&obj->value_["abstract"]), nullptr);
2309 ASSERT_EQ(std::get<std::string>(obj->value_["abstract"]), "plainTextAbstract");
2310
2311 ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&obj->value_["details"]), nullptr);
2312 obj2 = std::get<std::shared_ptr<Object>>(obj->value_["details"]);
2313
2314 ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail1"]), nullptr);
2315 ASSERT_EQ(std::get<std::string>(obj2->value_["detail1"]), "detail1");
2316 ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail2"]), nullptr);
2317 ASSERT_EQ(std::get<std::string>(obj2->value_["detail2"]), "detail2");
2318 LOG_INFO(UDMF_TEST, "QueryUDSData002 end.");
2319 }
2320
2321 /**
2322 * @tc.name: QueryUDSData003
2323 * @tc.desc: QueryUDSData003
2324 * @tc.type: FUNC
2325 */
2326 HWTEST_F(UdmfClientTest, QueryUDSData003, TestSize.Level1)
2327 {
2328 LOG_INFO(UDMF_TEST, "QueryUDSData003 begin.");
2329
2330 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
2331 std::vector<UnifiedData> unifiedDataSet;
2332 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
2333 ASSERT_EQ(status, E_OK);
2334 unifiedDataSet.clear();
2335 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
2336 ASSERT_EQ(status, E_OK);
2337 ASSERT_TRUE(unifiedDataSet.empty());
2338
2339 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
2340 UnifiedData data;
2341 auto obj = std::make_shared<Object>();
2342 obj->value_["uniformDataType"] = "general.hyperlink";
2343 obj->value_["url"] = "www.xxx";
2344 obj->value_["description"] = "hyperlinkDescription";
2345 auto obj2 = std::make_shared<Object>();
2346 obj2->value_["detail1"] = "detail1";
2347 obj2->value_["detail2"] = "detail2";
2348 obj->value_["details"] = obj2;
2349 auto record = std::make_shared<Link>(UDType::HYPERLINK, obj);
2350 data.AddRecord(record);
2351 std::string key;
2352 status = UdmfClient::GetInstance().SetData(customOption, data, key);
2353 ASSERT_EQ(status, E_OK);
2354
2355 unifiedDataSet.clear();
2356 query = { .key = key, .intention = UD_INTENTION_DATA_HUB };
2357 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
2358 ASSERT_EQ(status, E_OK);
2359 ASSERT_EQ(unifiedDataSet.size(), 1);
2360 auto record2 = unifiedDataSet[0].GetRecordAt(0);
2361 ASSERT_NE(record2, nullptr);
2362 ASSERT_EQ(record2->GetType(), UDType::HYPERLINK);
2363 auto value = record2->GetValue();
2364
2365 ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&value), nullptr);
2366 obj = std::get<std::shared_ptr<Object>>(value);
2367
2368 ASSERT_NE(std::get_if<std::string>(&obj->value_["uniformDataType"]), nullptr);
2369 ASSERT_EQ(std::get<std::string>(obj->value_["uniformDataType"]), "general.hyperlink");
2370 ASSERT_NE(std::get_if<std::string>(&obj->value_["url"]), nullptr);
2371 ASSERT_EQ(std::get<std::string>(obj->value_["url"]), "www.xxx");
2372 ASSERT_NE(std::get_if<std::string>(&obj->value_["description"]), nullptr);
2373 ASSERT_EQ(std::get<std::string>(obj->value_["description"]), "hyperlinkDescription");
2374
2375 ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&obj->value_["details"]), nullptr);
2376 obj2 = std::get<std::shared_ptr<Object>>(obj->value_["details"]);
2377
2378 ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail1"]), nullptr);
2379 ASSERT_EQ(std::get<std::string>(obj2->value_["detail1"]), "detail1");
2380 ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail2"]), nullptr);
2381 ASSERT_EQ(std::get<std::string>(obj2->value_["detail2"]), "detail2");
2382 LOG_INFO(UDMF_TEST, "QueryUDSData003 end.");
2383 }
2384
2385 /**
2386 * @tc.name: QueryUDSData004
2387 * @tc.desc: QueryUDSData004
2388 * @tc.type: FUNC
2389 */
2390 HWTEST_F(UdmfClientTest, QueryUDSData004, TestSize.Level1)
2391 {
2392 LOG_INFO(UDMF_TEST, "QueryUDSData004 begin.");
2393
2394 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
2395 std::vector<UnifiedData> unifiedDataSet;
2396 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
2397 ASSERT_EQ(status, E_OK);
2398 unifiedDataSet.clear();
2399 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
2400 ASSERT_EQ(status, E_OK);
2401 ASSERT_TRUE(unifiedDataSet.empty());
2402
2403 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
2404 UnifiedData data;
2405 auto obj = std::make_shared<Object>();
2406 obj->value_["uniformDataType"] = "general.html";
2407 obj->value_["htmlContent"] = "www.xxx";
2408 obj->value_["plainContent"] = "htmlPlainContent";
2409 auto obj2 = std::make_shared<Object>();
2410 obj2->value_["detail1"] = "detail1";
2411 obj2->value_["detail2"] = "detail2";
2412 obj->value_["details"] = obj2;
2413 auto record = std::make_shared<Html>(UDType::HTML, obj);
2414 data.AddRecord(record);
2415 std::string key;
2416 status = UdmfClient::GetInstance().SetData(customOption, data, key);
2417 ASSERT_EQ(status, E_OK);
2418
2419 unifiedDataSet.clear();
2420 query = { .key = key, .intention = UD_INTENTION_DATA_HUB };
2421 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
2422 ASSERT_EQ(status, E_OK);
2423 ASSERT_EQ(unifiedDataSet.size(), 1);
2424 auto record2 = unifiedDataSet[0].GetRecordAt(0);
2425 ASSERT_NE(record2, nullptr);
2426 ASSERT_EQ(record2->GetType(), UDType::HTML);
2427 auto value = record2->GetValue();
2428
2429 ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&value), nullptr);
2430 obj = std::get<std::shared_ptr<Object>>(value);
2431
2432 ASSERT_NE(std::get_if<std::string>(&obj->value_["uniformDataType"]), nullptr);
2433 ASSERT_EQ(std::get<std::string>(obj->value_["uniformDataType"]), "general.html");
2434 ASSERT_NE(std::get_if<std::string>(&obj->value_["htmlContent"]), nullptr);
2435 ASSERT_EQ(std::get<std::string>(obj->value_["htmlContent"]), "www.xxx");
2436 ASSERT_NE(std::get_if<std::string>(&obj->value_["plainContent"]), nullptr);
2437 ASSERT_EQ(std::get<std::string>(obj->value_["plainContent"]), "htmlPlainContent");
2438
2439 ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&obj->value_["details"]), nullptr);
2440 obj2 = std::get<std::shared_ptr<Object>>(obj->value_["details"]);
2441
2442 ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail1"]), nullptr);
2443 ASSERT_EQ(std::get<std::string>(obj2->value_["detail1"]), "detail1");
2444 ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail2"]), nullptr);
2445 ASSERT_EQ(std::get<std::string>(obj2->value_["detail2"]), "detail2");
2446 LOG_INFO(UDMF_TEST, "QueryUDSData004 end.");
2447 }
2448
2449 /**
2450 * @tc.name: QueryUDSData005
2451 * @tc.desc: QueryUDSData005
2452 * @tc.type: FUNC
2453 */
2454 HWTEST_F(UdmfClientTest, QueryUDSData005, TestSize.Level1)
2455 {
2456 LOG_INFO(UDMF_TEST, "QueryUDSData005 begin.");
2457
2458 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
2459 std::vector<UnifiedData> unifiedDataSet;
2460 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
2461 ASSERT_EQ(status, E_OK);
2462 unifiedDataSet.clear();
2463 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
2464 ASSERT_EQ(status, E_OK);
2465 ASSERT_TRUE(unifiedDataSet.empty());
2466
2467 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
2468 UnifiedData data;
2469 auto obj = std::make_shared<Object>();
2470 obj->value_["uniformDataType"] = "openharmony.app-item";
2471 obj->value_["appId"] = "app-itemAppId";
2472 obj->value_["appName"] = "app-itemAppName";
2473 obj->value_["appIconId"] = "app-itemAppIconId";
2474 obj->value_["appLabelId"] = "app-itemAppLabelId";
2475 obj->value_["bundleName"] = "app-itemBundleName";
2476 obj->value_["abilityName"] = "app-itemAbilityName";
2477 auto obj2 = std::make_shared<Object>();
2478 obj2->value_["detail1"] = "detail1";
2479 obj2->value_["detail2"] = 1234;
2480 obj->value_["details"] = obj2;
2481 auto record = std::make_shared<SystemDefinedAppItem>(UDType::SYSTEM_DEFINED_APP_ITEM, obj);
2482 data.AddRecord(record);
2483 std::string key;
2484 status = UdmfClient::GetInstance().SetData(customOption, data, key);
2485 ASSERT_EQ(status, E_OK);
2486
2487 unifiedDataSet.clear();
2488 query = { .key = key, .intention = UD_INTENTION_DATA_HUB };
2489 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
2490 ASSERT_EQ(status, E_OK);
2491 ASSERT_EQ(unifiedDataSet.size(), 1);
2492 auto record2 = unifiedDataSet[0].GetRecordAt(0);
2493 ASSERT_NE(record2, nullptr);
2494 ASSERT_EQ(record2->GetType(), UDType::SYSTEM_DEFINED_APP_ITEM);
2495 auto value = record2->GetValue();
2496
2497 ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&value), nullptr);
2498 obj = std::get<std::shared_ptr<Object>>(value);
2499
2500 ASSERT_NE(std::get_if<std::string>(&obj->value_["uniformDataType"]), nullptr);
2501 ASSERT_EQ(std::get<std::string>(obj->value_["uniformDataType"]), "openharmony.app-item");
2502 ASSERT_NE(std::get_if<std::string>(&obj->value_["appId"]), nullptr);
2503 ASSERT_EQ(std::get<std::string>(obj->value_["appId"]), "app-itemAppId");
2504 ASSERT_NE(std::get_if<std::string>(&obj->value_["appName"]), nullptr);
2505 ASSERT_EQ(std::get<std::string>(obj->value_["appName"]), "app-itemAppName");
2506 ASSERT_NE(std::get_if<std::string>(&obj->value_["appIconId"]), nullptr);
2507 ASSERT_EQ(std::get<std::string>(obj->value_["appIconId"]), "app-itemAppIconId");
2508 ASSERT_NE(std::get_if<std::string>(&obj->value_["appLabelId"]), nullptr);
2509 ASSERT_EQ(std::get<std::string>(obj->value_["appLabelId"]), "app-itemAppLabelId");
2510 ASSERT_NE(std::get_if<std::string>(&obj->value_["bundleName"]), nullptr);
2511 ASSERT_EQ(std::get<std::string>(obj->value_["bundleName"]), "app-itemBundleName");
2512 ASSERT_NE(std::get_if<std::string>(&obj->value_["abilityName"]), nullptr);
2513 ASSERT_EQ(std::get<std::string>(obj->value_["abilityName"]), "app-itemAbilityName");
2514
2515 ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&obj->value_["details"]), nullptr);
2516 obj2 = std::get<std::shared_ptr<Object>>(obj->value_["details"]);
2517
2518 ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail1"]), nullptr);
2519 ASSERT_EQ(std::get<std::string>(obj2->value_["detail1"]), "detail1");
2520 ASSERT_NE(std::get_if<int32_t>(&obj2->value_["detail2"]), nullptr);
2521 ASSERT_EQ(std::get<int32_t>(obj2->value_["detail2"]), 1234);
2522 LOG_INFO(UDMF_TEST, "QueryUDSData005 end.");
2523 }
2524
2525 /**
2526 * @tc.name: GetSummary004
2527 * @tc.desc: Get summary data for entries
2528 * @tc.type: FUNC
2529 */
2530 HWTEST_F(UdmfClientTest, GetSummary004, TestSize.Level1)
2531 {
2532 LOG_INFO(UDMF_TEST, "GetSummary004 begin.");
2533
2534 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2535 UnifiedData data;
2536 std::string key;
2537
2538 UDDetails details;
2539 details.insert({ "udmf_key", "udmf_value" });
2540
2541 std::shared_ptr<Object> obj = std::make_shared<Object>();
2542 obj->value_[UNIFORM_DATA_TYPE] = "general.file-uri";
2543 obj->value_[FILE_URI_PARAM] = "http://demo.com";
2544 obj->value_[FILE_TYPE] = "abcdefg";
2545 auto record = std::make_shared<UnifiedRecord>(FILE_URI, obj);
2546 auto size0 = record->GetSize();
2547
2548 auto plainText = PlainText("content", "abstract");
2549 auto size1 = plainText.GetSize();
2550 plainText.InitObject();
2551 record->AddEntry(plainText.GetUtdId(), plainText.GetOriginValue());
2552
2553 auto image = Image("uri");
2554 image.SetDetails(details);
2555 auto size2 = image.GetSize();
2556 image.InitObject();
2557 record->AddEntry(image.GetUtdId(), image.GetOriginValue());
2558
2559 std::vector<uint8_t> raw = {1, 2, 3, 4, 5};
2560 SystemDefinedPixelMap pixelMap = SystemDefinedPixelMap(raw);
2561 pixelMap.SetDetails(details);
2562 auto size3 = pixelMap.GetSize();
2563 pixelMap.InitObject();
2564 record->AddEntry(pixelMap.GetUtdId(), pixelMap.GetOriginValue());
2565
2566 raw = {1, 2, 3, 4, 5};
2567 auto applicationDefinedRecord = ApplicationDefinedRecord("my.type", raw);
2568 auto size4 = applicationDefinedRecord.GetSize();
2569 applicationDefinedRecord.InitObject();
2570 record->AddEntry(applicationDefinedRecord.GetUtdId(), applicationDefinedRecord.GetOriginValue());
2571
2572 data.AddRecord(record);
2573
2574 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
2575 ASSERT_EQ(status, E_OK);
2576
2577 QueryOption option2 = { .key = key };
2578 Summary summary;
2579 status = UdmfClient::GetInstance().GetSummary(option2, summary);
2580
2581 ASSERT_EQ(status, E_OK);
2582 EXPECT_EQ(summary.summary["general.file-uri"], size0);
2583 EXPECT_EQ(summary.summary["general.plain-text"], size1);
2584 EXPECT_EQ(summary.summary["general.image"], size2);
2585 EXPECT_EQ(summary.summary["openharmony.pixel-map"], size3);
2586 EXPECT_EQ(summary.summary["ApplicationDefinedType"], size4);
2587
2588 EXPECT_EQ(summary.totalSize, record->GetSize());
2589
2590 UnifiedData readData;
2591 status = UdmfClient::GetInstance().GetData(option2, readData);
2592 ASSERT_EQ(E_OK, status);
2593 ASSERT_EQ(1, readData.GetRecords().size());
2594 auto readRecord = readData.GetRecordAt(0);
2595 auto entries = readRecord->GetEntries();
2596 ASSERT_EQ(5, entries->size());
2597 auto readFileUri = std::get<std::shared_ptr<Object>>(entries->at("general.file-uri"));
2598 EXPECT_EQ("abcdefg", std::get<std::string>(readFileUri->value_[FILE_TYPE]));
2599 auto readPlainText = std::get<std::shared_ptr<Object>>(entries->at("general.plain-text"));
2600 EXPECT_EQ("abstract", std::get<std::string>(readPlainText->value_[ABSTRACT]));
2601 auto readImage = std::get<std::shared_ptr<Object>>(entries->at("general.image"));
2602 EXPECT_EQ("uri", std::get<std::string>(readImage->value_[ORI_URI]));
2603 auto readPixelMap = std::get<std::shared_ptr<Object>>(entries->at("openharmony.pixel-map"));
2604 EXPECT_EQ(5, std::get<std::vector<uint8_t>>(readPixelMap->value_[PIXEL_MAP]).size());
2605 auto readDefinedRecord = std::get<std::shared_ptr<Object>>(entries->at("my.type"));
2606 EXPECT_EQ(5, std::get<std::vector<uint8_t>>(readDefinedRecord->value_[RAW_DATA]).size());
2607 auto value = std::get<std::shared_ptr<Object>>(readRecord->GetValue());
2608 EXPECT_EQ("abcdefg", std::get<std::string>(value->value_[FILE_TYPE]));
2609 LOG_INFO(UDMF_TEST, "GetSummary004 end.");
2610 }
2611
2612 /**
2613 * @tc.name: GetSummary005
2614 * @tc.desc: Get summary data for entries
2615 * @tc.type: FUNC
2616 */
2617 HWTEST_F(UdmfClientTest, GetSummary005, TestSize.Level1)
2618 {
2619 LOG_INFO(UDMF_TEST, "GetSummary005 begin.");
2620
2621 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
2622 UnifiedData data;
2623 std::string key;
2624
2625 UDDetails details;
2626 details.insert({ "udmf_key", "udmf_value" });
2627
2628 auto record = std::make_shared<Html>("content1", "content2");
2629 auto size0 = record->GetSize();
2630
2631 auto link = Link("url", "descritpion");
2632 auto size1 = link.GetSize();
2633 link.InitObject();
2634 record->AddEntry(link.GetUtdId(), link.GetOriginValue());
2635
2636 auto folder = Folder("uri");
2637 folder.SetDetails(details);
2638 auto size2 = folder.GetSize();
2639 folder.InitObject();
2640 record->AddEntry(folder.GetUtdId(), folder.GetOriginValue());
2641
2642 std::vector<uint8_t> raw = {1, 2, 3, 4, 5};
2643 auto applicationDefinedRecord1 = ApplicationDefinedRecord("your.type", raw);
2644 auto size3 = applicationDefinedRecord1.GetSize();
2645 applicationDefinedRecord1.InitObject();
2646 record->AddEntry(applicationDefinedRecord1.GetUtdId(), applicationDefinedRecord1.GetOriginValue());
2647
2648 raw = {1, 2, 3, 4, 5};
2649 auto applicationDefinedRecord2 = ApplicationDefinedRecord("my.type", raw);
2650 auto size4 = applicationDefinedRecord2.GetSize();
2651 applicationDefinedRecord2.InitObject();
2652 record->AddEntry(applicationDefinedRecord2.GetUtdId(), applicationDefinedRecord2.GetOriginValue());
2653
2654 auto form = SystemDefinedForm();
2655 form.SetDetails(details);
2656 form.SetDetails(details);
2657 form.SetFormId(123);
2658 form.SetFormName("formName");
2659 form.SetModule("module");
2660 form.SetAbilityName("abilityName");
2661 form.SetBundleName("bundleName");
2662 auto size5 = form.GetSize();
2663 form.InitObject();
2664 record->AddEntry(form.GetUtdId(), form.GetOriginValue());
2665
2666 raw = {1, 2, 3, 4, 5};
2667 std::shared_ptr<Object> obj = std::make_shared<Object>();
2668 obj->value_[UNIFORM_DATA_TYPE] = "general.content-form";
2669 obj->value_[THUMB_DATA] = raw;
2670 obj->value_[THUMB_DATA_LENGTH] = 5;
2671 obj->value_[DESCRIPTION] = "descritpion";
2672 obj->value_[TITLE] = "title";
2673 obj->value_[APP_ICON] = raw;
2674 obj->value_[APP_ICON_LENGTH] = 5;
2675 obj->value_[APP_NAME] = "appName";
2676 obj->value_[LINK_URL] = "linkUri";
2677 auto contentForm = UnifiedRecord(CONTENT_FORM, obj);
2678 auto size6 = contentForm.GetSize();
2679 record->AddEntry(contentForm.GetUtdId(), contentForm.GetOriginValue());
2680
2681 data.AddRecord(record);
2682
2683 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
2684 ASSERT_EQ(status, E_OK);
2685
2686 QueryOption option2 = { .key = key };
2687 Summary summary;
2688 status = UdmfClient::GetInstance().GetSummary(option2, summary);
2689
2690 LOG_INFO(UDMF_TEST, "GetSummary005 GetSummary.");
2691
2692 ASSERT_EQ(status, E_OK);
2693 EXPECT_EQ(summary.summary["general.html"], size0);
2694 EXPECT_EQ(summary.summary["general.hyperlink"], size1);
2695 EXPECT_EQ(summary.summary["general.folder"], size2);
2696 EXPECT_EQ(summary.summary["ApplicationDefinedType"], size3 + size4);
2697 EXPECT_EQ(summary.summary["openharmony.form"], size5);
2698 EXPECT_EQ(summary.summary["general.content-form"], size6);
2699
2700 EXPECT_EQ(summary.totalSize, record->GetSize());
2701
2702 UnifiedData readData;
2703 status = UdmfClient::GetInstance().GetData(option2, readData);
2704 LOG_INFO(UDMF_TEST, "GetSummary005 GetSummary1.");
2705 ASSERT_EQ(E_OK, status);
2706 ASSERT_EQ(1, readData.GetRecords().size());
2707 auto readRecord = readData.GetRecordAt(0);
2708 ValueType recordVal = readRecord->GetValue();
2709 auto entries = readRecord->GetEntries();
2710 ASSERT_EQ(7, entries->size());
2711 auto readHtml = std::get<std::shared_ptr<Object>>(entries->at("general.html"));
2712 EXPECT_EQ("content1", std::get<std::string>(readHtml->value_[HTML_CONTENT]));
2713 auto readHyperlink = std::get<std::shared_ptr<Object>>(entries->at("general.hyperlink"));
2714 EXPECT_EQ("descritpion", std::get<std::string>(readHyperlink->value_[DESCRIPTION]));
2715 auto readFolder = std::get<std::shared_ptr<Object>>(entries->at("general.folder"));
2716 EXPECT_EQ("uri", std::get<std::string>(readFolder->value_[ORI_URI]));
2717 auto readDefinedRecord = std::get<std::shared_ptr<Object>>(entries->at("your.type"));
2718 EXPECT_EQ(5, std::get<std::vector<uint8_t>>(readDefinedRecord->value_[RAW_DATA]).size());
2719 auto readDefinedRecord2 = std::get<std::shared_ptr<Object>>(entries->at("my.type"));
2720 EXPECT_EQ(5, std::get<std::vector<uint8_t>>(readDefinedRecord2->value_[RAW_DATA]).size());
2721 auto readForm = std::get<std::shared_ptr<Object>>(entries->at("openharmony.form"));
2722 EXPECT_EQ("module", std::get<std::string>(readForm->value_[MODULE]));
2723 auto readCotentForm = std::get<std::shared_ptr<Object>>(entries->at("general.content-form"));
2724 EXPECT_EQ("title", std::get<std::string>(readCotentForm->value_[TITLE]));
2725 LOG_INFO(UDMF_TEST, "GetSummary005 end.");
2726 }
2727
2728 } // OHOS::Test