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
16 #include <gtest/gtest.h>
17
18 #include <unistd.h>
19
20 #include "token_setproc.h"
21 #include "accesstoken_kit.h"
22 #include "nativetoken_kit.h"
23
24 #include "logger.h"
25 #include "udmf_client.h"
26 #include "application_defined_record.h"
27 #include "audio.h"
28 #include "file.h"
29 #include "folder.h"
30 #include "html.h"
31 #include "image.h"
32 #include "link.h"
33 #include "plain_text.h"
34 #include "system_defined_appitem.h"
35 #include "system_defined_form.h"
36 #include "system_defined_pixelmap.h"
37 #include "system_defined_record.h"
38 #include "text.h"
39 #include "video.h"
40
41 using namespace testing::ext;
42 using namespace OHOS::Security::AccessToken;
43 using namespace OHOS::UDMF;
44 using namespace OHOS;
45 namespace OHOS::Test {
46 class UdmfClientTest : public testing::Test {
47 public:
48 static void SetUpTestCase();
49 static void TearDownTestCase();
50 void SetUp() override;
51 void TearDown() override;
52
53 void SetNativeToken();
54 static void AllocHapToken1();
55 static void AllocHapToken2();
56 void SetHapToken1();
57 void SetHapToken2();
58
59 void AddPrivilege(QueryOption &option);
60 void CompareDetails(const UDDetails &details);
61 void GetEmptyData(QueryOption &option);
62
63 static constexpr int USER_ID = 100;
64 static constexpr int INST_INDEX = 0;
65 };
66
SetUpTestCase()67 void UdmfClientTest::SetUpTestCase()
68 {
69 AllocHapToken1();
70 AllocHapToken2();
71 }
72
TearDownTestCase()73 void UdmfClientTest::TearDownTestCase()
74 {
75 auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo1", INST_INDEX);
76 AccessTokenKit::DeleteToken(tokenId);
77 tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo2", INST_INDEX);
78 AccessTokenKit::DeleteToken(tokenId);
79 }
80
SetUp()81 void UdmfClientTest::SetUp()
82 {
83 SetHapToken1();
84 }
85
TearDown()86 void UdmfClientTest::TearDown()
87 {
88 }
89
SetNativeToken()90 void UdmfClientTest::SetNativeToken()
91 {
92 auto tokenId = AccessTokenKit::GetNativeTokenId("msdp_sa");
93 SetSelfTokenID(tokenId);
94 }
95
AllocHapToken1()96 void UdmfClientTest::AllocHapToken1()
97 {
98 HapInfoParams info = {
99 .userID = USER_ID,
100 .bundleName = "ohos.test.demo1",
101 .instIndex = INST_INDEX,
102 .appIDDesc = "ohos.test.demo1"
103 };
104
105 HapPolicyParams policy = {
106 .apl = APL_NORMAL,
107 .domain = "test.domain",
108 .permList = {
109 {
110 .permissionName = "ohos.permission.test",
111 .bundleName = "ohos.test.demo1",
112 .grantMode = 1,
113 .availableLevel = APL_NORMAL,
114 .label = "label",
115 .labelId = 1,
116 .description = "test1",
117 .descriptionId = 1
118 }
119 },
120 .permStateList = {
121 {
122 .permissionName = "ohos.permission.test",
123 .isGeneral = true,
124 .resDeviceID = { "local" },
125 .grantStatus = { PermissionState::PERMISSION_GRANTED },
126 .grantFlags = { 1 }
127 }
128 }
129 };
130 auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
131 SetSelfTokenID(tokenID.tokenIDEx);
132 }
133
AllocHapToken2()134 void UdmfClientTest::AllocHapToken2()
135 {
136 HapInfoParams info = {
137 .userID = USER_ID,
138 .bundleName = "ohos.test.demo2",
139 .instIndex = INST_INDEX,
140 .appIDDesc = "ohos.test.demo2"
141 };
142
143 HapPolicyParams policy = {
144 .apl = APL_NORMAL,
145 .domain = "test.domain",
146 .permList = {
147 {
148 .permissionName = "ohos.permission.test",
149 .bundleName = "ohos.test.demo2",
150 .grantMode = 1,
151 .availableLevel = APL_NORMAL,
152 .label = "label",
153 .labelId = 1,
154 .description = "test2",
155 .descriptionId = 1
156 }
157 },
158 .permStateList = {
159 {
160 .permissionName = "ohos.permission.test",
161 .isGeneral = true,
162 .resDeviceID = { "local" },
163 .grantStatus = { PermissionState::PERMISSION_GRANTED },
164 .grantFlags = { 1 }
165 }
166 }
167 };
168 auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
169 SetSelfTokenID(tokenID.tokenIDEx);
170 }
171
SetHapToken1()172 void UdmfClientTest::SetHapToken1()
173 {
174 auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo1", INST_INDEX);
175 SetSelfTokenID(tokenId);
176 }
177
SetHapToken2()178 void UdmfClientTest::SetHapToken2()
179 {
180 auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo2", INST_INDEX);
181 SetSelfTokenID(tokenId);
182 }
183
AddPrivilege(QueryOption & option)184 void UdmfClientTest::AddPrivilege(QueryOption &option)
185 {
186 Privilege privilege;
187 privilege.tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo2", INST_INDEX);
188 privilege.readPermission = "readPermission";
189 privilege.writePermission = "writePermission";
190 SetNativeToken();
191 auto status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
192 ASSERT_EQ(status, E_OK);
193 }
194
CompareDetails(const UDDetails & details)195 void UdmfClientTest::CompareDetails(const UDDetails &details)
196 {
197 for (const auto &detail : details) {
198 auto key = detail.first;
199 EXPECT_EQ(key, "udmf_key");
200 auto value = detail.second;
201 auto str = std::get<std::string>(value);
202 EXPECT_EQ(str, "udmf_value");
203 }
204 }
205
GetEmptyData(QueryOption & option)206 void UdmfClientTest::GetEmptyData(QueryOption &option)
207 {
208 UnifiedData data;
209 auto status = UdmfClient::GetInstance().GetData(option, data);
210 EXPECT_EQ(status, E_NOT_FOUND);
211 }
212
213 /**
214 * @tc.name: SetData001
215 * @tc.desc: Set data with invalid params
216 * @tc.type: FUNC
217 */
218 HWTEST_F(UdmfClientTest, SetData001, TestSize.Level1)
219 {
220 LOG_INFO(UDMF_TEST, "SetData001 begin.");
221
222 CustomOption option = { .intention = Intention::UD_INTENTION_DRAG };
223 UnifiedData data;
224 std::string key;
225 auto status = UdmfClient::GetInstance().SetData(option, data, key);
226 EXPECT_EQ(status, E_INVALID_PARAMETERS);
227
228 option = { .intention = Intention::UD_INTENTION_BUTT };
229 Text text;
230 UDDetails details;
231 details.insert({ "udmf_key", "udmf_value" });
232 text.SetDetails(details);
233 std::shared_ptr<UnifiedRecord> record = std::make_shared<Text>(text);
234 data.AddRecord(record);
235 status = UdmfClient::GetInstance().SetData(option, data, key);
236 EXPECT_EQ(status, E_INVALID_PARAMETERS);
237
238 option = {};
239 status = UdmfClient::GetInstance().SetData(option, data, key);
240 EXPECT_EQ(status, E_INVALID_PARAMETERS);
241
242 option = { .intention = Intention::UD_INTENTION_BASE };
243 status = UdmfClient::GetInstance().SetData(option, data, key);
244 EXPECT_EQ(status, E_INVALID_PARAMETERS);
245 LOG_INFO(UDMF_TEST, "SetData001 end.");
246 }
247
248 /**
249 * @tc.name: SetData002
250 * @tc.desc: Set Text record with valid params and get data
251 * @tc.type: FUNC
252 */
253 HWTEST_F(UdmfClientTest, SetData002, TestSize.Level1)
254 {
255 LOG_INFO(UDMF_TEST, "SetData002 begin.");
256
257 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
258 UnifiedData data1;
259 Text text1;
260 UDDetails details1;
261 details1.insert({ "udmf_key", "udmf_value" });
262 text1.SetDetails(details1);
263 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<Text>(text1);
264 data1.AddRecord(record1);
265 std::string key;
266 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
267 ASSERT_EQ(status, E_OK);
268
269 QueryOption option2 = { .key = key };
270 AddPrivilege(option2);
271 SetHapToken2();
272 UnifiedData data2;
273 status = UdmfClient::GetInstance().GetData(option2, data2);
274 ASSERT_EQ(status, E_OK);
275
276 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
277 ASSERT_NE(record2, nullptr);
278 auto type = record2->GetType();
279 EXPECT_EQ(type, UDType::TEXT);
280
281 auto text2 = static_cast<Text *>(record2.get());
282 ASSERT_NE(text2, nullptr);
283 CompareDetails(text2->GetDetails());
284
285 GetEmptyData(option2);
286
287 LOG_INFO(UDMF_TEST, "SetData002 end.");
288 }
289
290 /**
291 * @tc.name: SetData003
292 * @tc.desc: Set PlainText record with valid params and get data
293 * @tc.type: FUNC
294 */
295 HWTEST_F(UdmfClientTest, SetData003, TestSize.Level1)
296 {
297 LOG_INFO(UDMF_TEST, "SetData003 begin.");
298
299 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
300 UnifiedData data1;
301 PlainText plainText1;
302 UDDetails details1;
303 details1.insert({ "udmf_key", "udmf_value" });
304 plainText1.SetDetails(details1);
305 plainText1.SetContent("content");
306 plainText1.SetAbstract("abstract");
307 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<PlainText>(plainText1);
308 data1.AddRecord(record1);
309 std::string key;
310 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
311 ASSERT_EQ(status, E_OK);
312
313 QueryOption option2 = { .key = key };
314 AddPrivilege(option2);
315 SetHapToken2();
316 UnifiedData data2;
317 status = UdmfClient::GetInstance().GetData(option2, data2);
318 ASSERT_EQ(status, E_OK);
319
320 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
321 ASSERT_NE(record2, nullptr);
322 auto type = record2->GetType();
323 ASSERT_EQ(type, UDType::PLAIN_TEXT);
324
325 auto text2 = static_cast<Text *>(record2.get());
326 ASSERT_NE(text2, nullptr);
327 CompareDetails(text2->GetDetails());
328
329 auto plainText2 = static_cast<PlainText *>(record2.get());
330 ASSERT_NE(plainText2, nullptr);
331 EXPECT_EQ(plainText1.GetContent(), plainText2->GetContent());
332 EXPECT_EQ(plainText1.GetAbstract(), plainText2->GetAbstract());
333
334 GetEmptyData(option2);
335
336 LOG_INFO(UDMF_TEST, "SetData003 end.");
337 }
338
339 /**
340 * @tc.name: SetData004
341 * @tc.desc: Set Html record with valid params and get data
342 * @tc.type: FUNC
343 */
344 HWTEST_F(UdmfClientTest, SetData004, TestSize.Level1)
345 {
346 LOG_INFO(UDMF_TEST, "SetData004 begin.");
347
348 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
349 UnifiedData data1;
350 std::string key;
351 Html html1;
352 UDDetails details1;
353 details1.insert({ "udmf_key", "udmf_value" });
354 html1.SetDetails(details1);
355 html1.SetHtmlContent("htmlcontent");
356 html1.SetPlainContent("plainContent");
357 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<Html>(html1);
358 data1.AddRecord(record1);
359 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
360 ASSERT_EQ(status, E_OK);
361
362 QueryOption option2 = { .key = key };
363 AddPrivilege(option2);
364 SetHapToken2();
365 UnifiedData data2;
366 status = UdmfClient::GetInstance().GetData(option2, data2);
367 ASSERT_EQ(status, E_OK);
368
369 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
370 ASSERT_NE(record2, nullptr);
371 auto type = record2->GetType();
372 ASSERT_EQ(type, UDType::HTML);
373
374 auto text2 = static_cast<Text *>(record2.get());
375 ASSERT_NE(text2, nullptr);
376 CompareDetails(text2->GetDetails());
377
378 auto html2 = static_cast<Html *>(record2.get());
379 ASSERT_NE(html2, nullptr);
380 EXPECT_EQ(html1.GetHtmlContent(), html2->GetHtmlContent());
381 EXPECT_EQ(html1.GetPlainContent(), html2->GetPlainContent());
382
383 GetEmptyData(option2);
384
385 LOG_INFO(UDMF_TEST, "SetData004 end.");
386 }
387
388 /**
389 * @tc.name: SetData005
390 * @tc.desc: Set Link record with valid params and get data
391 * @tc.type: FUNC
392 */
393 HWTEST_F(UdmfClientTest, SetData005, TestSize.Level1)
394 {
395 LOG_INFO(UDMF_TEST, "SetData005 begin.");
396
397 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
398 UnifiedData data1;
399 std::string key;
400 Link link1;
401 UDDetails details1;
402 details1.insert({ "udmf_key", "udmf_value" });
403 link1.SetDetails(details1);
404 link1.SetUrl("url");
405 link1.SetDescription("description");
406 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<Link>(link1);
407 data1.AddRecord(record1);
408 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
409 ASSERT_EQ(status, E_OK);
410
411 QueryOption option2 = { .key = key };
412 AddPrivilege(option2);
413 SetHapToken2();
414 UnifiedData data2;
415 status = UdmfClient::GetInstance().GetData(option2, data2);
416 ASSERT_EQ(status, E_OK);
417
418 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
419 ASSERT_NE(record2, nullptr);
420 auto type = record2->GetType();
421 ASSERT_EQ(type, UDType::HYPERLINK);
422
423 auto text2 = static_cast<Text *>(record2.get());
424 ASSERT_NE(text2, nullptr);
425 CompareDetails(text2->GetDetails());
426
427 auto link2 = static_cast<Link *>(record2.get());
428 ASSERT_NE(link2, nullptr);
429 EXPECT_EQ(link1.GetUrl(), link2->GetUrl());
430 EXPECT_EQ(link1.GetDescription(), link2->GetDescription());
431
432 GetEmptyData(option2);
433
434 LOG_INFO(UDMF_TEST, "SetData005 end.");
435 }
436
437 /**
438 * @tc.name: SetData006
439 * @tc.desc: Set File record with valid params and get data
440 * @tc.type: FUNC
441 */
442 HWTEST_F(UdmfClientTest, SetData006, TestSize.Level1)
443 {
444 LOG_INFO(UDMF_TEST, "SetData006 begin.");
445
446 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
447 UnifiedData data1;
448 std::string key;
449 File file1;
450 file1.SetRemoteUri("remoteUri");
451 UDDetails details1;
452 details1.insert({ "udmf_key", "udmf_value" });
453 file1.SetDetails(details1);
454 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<File>(file1);
455 data1.AddRecord(record1);
456 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
457 ASSERT_EQ(status, E_OK);
458
459 QueryOption option2 = { .key = key };
460 AddPrivilege(option2);
461 SetHapToken2();
462 UnifiedData data2;
463 status = UdmfClient::GetInstance().GetData(option2, data2);
464 ASSERT_EQ(status, E_OK);
465
466 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
467 ASSERT_NE(record2, nullptr);
468 auto type = record2->GetType();
469 ASSERT_EQ(type, UDType::FILE);
470
471 auto file2 = static_cast<File *>(record2.get());
472 ASSERT_NE(file2, nullptr);
473 EXPECT_EQ(file1.GetRemoteUri(), file2->GetRemoteUri());
474 CompareDetails(file2->GetDetails());
475
476 GetEmptyData(option2);
477
478 LOG_INFO(UDMF_TEST, "SetData006 end.");
479 }
480
481 /**
482 * @tc.name: SetData007
483 * @tc.desc: Set Image record with valid params and get data
484 * @tc.type: FUNC
485 */
486 HWTEST_F(UdmfClientTest, SetData007, TestSize.Level1)
487 {
488 LOG_INFO(UDMF_TEST, "SetData007 begin.");
489
490 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
491 UnifiedData data1;
492 std::string key;
493 Image image1;
494 UDDetails details1;
495 details1.insert({ "udmf_key", "udmf_value" });
496 image1.SetDetails(details1);
497 image1.SetRemoteUri("remoteUri");
498 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<Image>(image1);
499 data1.AddRecord(record1);
500 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
501 ASSERT_EQ(status, E_OK);
502
503 QueryOption option2 = { .key = key };
504 AddPrivilege(option2);
505 SetHapToken2();
506 UnifiedData data2;
507 status = UdmfClient::GetInstance().GetData(option2, data2);
508 ASSERT_EQ(status, E_OK);
509
510 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
511 ASSERT_NE(record2, nullptr);
512 auto type = record2->GetType();
513 ASSERT_EQ(type, UDType::IMAGE);
514
515 auto file2 = static_cast<File *>(record2.get());
516 ASSERT_NE(file2, nullptr);
517 CompareDetails(file2->GetDetails());
518
519 auto image2 = static_cast<Image *>(record2.get());
520 ASSERT_NE(image2, nullptr);
521 EXPECT_EQ(image1.GetRemoteUri(), image2->GetRemoteUri());
522
523 GetEmptyData(option2);
524
525 LOG_INFO(UDMF_TEST, "SetData007 end.");
526 }
527
528 /**
529 * @tc.name: SetData008
530 * @tc.desc: Set Video record with valid params and get data
531 * @tc.type: FUNC
532 */
533 HWTEST_F(UdmfClientTest, SetData008, TestSize.Level1)
534 {
535 LOG_INFO(UDMF_TEST, "SetData008 begin.");
536
537 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
538 UnifiedData data1;
539 std::string key;
540 Video video1;
541 UDDetails details1;
542 details1.insert({ "udmf_key", "udmf_value" });
543 video1.SetDetails(details1);
544 video1.SetRemoteUri("remoteUri");
545 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<Video>(video1);
546 data1.AddRecord(record1);
547 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
548 ASSERT_EQ(status, E_OK);
549
550 QueryOption option2 = { .key = key };
551 AddPrivilege(option2);
552 SetHapToken2();
553 UnifiedData data2;
554 status = UdmfClient::GetInstance().GetData(option2, data2);
555 ASSERT_EQ(status, E_OK);
556
557 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
558 ASSERT_NE(record2, nullptr);
559 auto type = record2->GetType();
560 EXPECT_EQ(type, UDType::VIDEO);
561
562 auto file2 = static_cast<File *>(record2.get());
563 ASSERT_NE(file2, nullptr);
564 CompareDetails(file2->GetDetails());
565
566 auto video2 = static_cast<Video *>(record2.get());
567 ASSERT_NE(video2, nullptr);
568 EXPECT_EQ(video1.GetRemoteUri(), video2->GetRemoteUri());
569
570 GetEmptyData(option2);
571
572 LOG_INFO(UDMF_TEST, "SetData008 end.");
573 }
574
575 /**
576 * @tc.name: SetData009
577 * @tc.desc: Set Audio record with valid params and get data
578 * @tc.type: FUNC
579 */
580 HWTEST_F(UdmfClientTest, SetData009, TestSize.Level1)
581 {
582 LOG_INFO(UDMF_TEST, "SetData009 begin.");
583
584 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
585 UnifiedData data1;
586 std::string key;
587 Audio audio1;
588 UDDetails details1;
589 details1.insert({ "udmf_key", "udmf_value" });
590 audio1.SetDetails(details1);
591 audio1.SetRemoteUri("remoteUri");
592 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<Audio>(audio1);
593 data1.AddRecord(record1);
594 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
595 ASSERT_EQ(status, E_OK);
596
597 QueryOption option2 = { .key = key };
598 AddPrivilege(option2);
599 SetHapToken2();
600 UnifiedData data2;
601 status = UdmfClient::GetInstance().GetData(option2, data2);
602 ASSERT_EQ(status, E_OK);
603
604 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
605 ASSERT_NE(record2, nullptr);
606 auto type = record2->GetType();
607 EXPECT_EQ(type, UDType::AUDIO);
608
609 auto file2 = static_cast<File *>(record2.get());
610 ASSERT_NE(file2, nullptr);
611 CompareDetails(file2->GetDetails());
612
613 auto audio2 = static_cast<Audio *>(record2.get());
614 ASSERT_NE(audio2, nullptr);
615 EXPECT_EQ(audio1.GetRemoteUri(), audio2->GetRemoteUri());
616
617 GetEmptyData(option2);
618
619 LOG_INFO(UDMF_TEST, "SetData009 end.");
620 }
621
622 /**
623 * @tc.name: SetData010
624 * @tc.desc: Set Folder record with valid params and get data
625 * @tc.type: FUNC
626 */
627 HWTEST_F(UdmfClientTest, SetData010, TestSize.Level1)
628 {
629 LOG_INFO(UDMF_TEST, "SetData010 begin.");
630
631 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
632 UnifiedData data1;
633 std::string key;
634 Folder folder1;
635 UDDetails details1;
636 details1.insert({ "udmf_key", "udmf_value" });
637 folder1.SetDetails(details1);
638 folder1.SetRemoteUri("remoteUri");
639 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<Folder>(folder1);
640 data1.AddRecord(record1);
641 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
642 ASSERT_EQ(status, E_OK);
643
644 QueryOption option2 = { .key = key };
645 AddPrivilege(option2);
646 SetHapToken2();
647 UnifiedData data2;
648 status = UdmfClient::GetInstance().GetData(option2, data2);
649 ASSERT_EQ(status, E_OK);
650
651 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
652 ASSERT_NE(record2, nullptr);
653 auto type = record2->GetType();
654 EXPECT_EQ(type, UDType::FOLDER);
655
656 auto file2 = static_cast<File *>(record2.get());
657 ASSERT_NE(file2, nullptr);
658 CompareDetails(file2->GetDetails());
659
660 auto folder2 = static_cast<Folder *>(record2.get());
661 ASSERT_NE(folder2, nullptr);
662 EXPECT_EQ(folder1.GetRemoteUri(), folder2->GetRemoteUri());
663
664 GetEmptyData(option2);
665
666 LOG_INFO(UDMF_TEST, "SetData010 end.");
667 }
668
669 /**
670 * @tc.name: SetData011
671 * @tc.desc: Set SystemDefined record with valid params and get data
672 * @tc.type: FUNC
673 */
674 HWTEST_F(UdmfClientTest, SetData011, TestSize.Level1)
675 {
676 LOG_INFO(UDMF_TEST, "SetData011 begin.");
677
678 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
679 UnifiedData data1;
680 std::string key;
681 SystemDefinedRecord systemDefinedRecord1;
682 UDDetails details1;
683 details1.insert({ "udmf_key", "udmf_value" });
684 systemDefinedRecord1.SetDetails(details1);
685 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<SystemDefinedRecord>(systemDefinedRecord1);
686 data1.AddRecord(record1);
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 SystemDefinedForm systemDefinedForm1;
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 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<SystemDefinedForm>(systemDefinedForm1);
733 data1.AddRecord(record1);
734 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
735 ASSERT_EQ(status, E_OK);
736
737 QueryOption option2 = { .key = key };
738 AddPrivilege(option2);
739 SetHapToken2();
740 UnifiedData data2;
741 status = UdmfClient::GetInstance().GetData(option2, data2);
742 ASSERT_EQ(status, E_OK);
743
744 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
745 ASSERT_NE(record2, nullptr);
746 auto type = record2->GetType();
747 ASSERT_EQ(type, UDType::SYSTEM_DEFINED_FORM);
748
749 auto systemDefinedRecord2 = static_cast<SystemDefinedRecord *>(record2.get());
750 ASSERT_NE(systemDefinedRecord2, nullptr);
751 CompareDetails(systemDefinedRecord2->GetDetails());
752
753 auto systemDefinedForm2 = static_cast<SystemDefinedForm *>(record2.get());
754 ASSERT_NE(systemDefinedForm2, nullptr);
755 EXPECT_EQ(systemDefinedForm1.GetFormId(), systemDefinedForm2->GetFormId());
756 EXPECT_EQ(systemDefinedForm1.GetFormName(), systemDefinedForm2->GetFormName());
757 EXPECT_EQ(systemDefinedForm1.GetBundleName(), systemDefinedForm2->GetBundleName());
758 EXPECT_EQ(systemDefinedForm1.GetAbilityName(), systemDefinedForm2->GetAbilityName());
759 EXPECT_EQ(systemDefinedForm1.GetModule(), systemDefinedForm2->GetModule());
760
761 GetEmptyData(option2);
762
763 LOG_INFO(UDMF_TEST, "SetData012 end.");
764 }
765
766 /**
767 * @tc.name: SetData013
768 * @tc.desc: Set AppItem record with valid params and get data
769 * @tc.type: FUNC
770 */
771 HWTEST_F(UdmfClientTest, SetData013, TestSize.Level1)
772 {
773 LOG_INFO(UDMF_TEST, "SetData013 begin.");
774
775 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
776 UnifiedData data1;
777 std::string key;
778 SystemDefinedAppItem systemDefinedAppItem1;
779 UDDetails details1;
780 details1.insert({ "udmf_key", "udmf_value" });
781 systemDefinedAppItem1.SetDetails(details1);
782 systemDefinedAppItem1.SetAppId("appId");
783 systemDefinedAppItem1.SetAppName("appName");
784 systemDefinedAppItem1.SetAppIconId("appIconId");
785 systemDefinedAppItem1.SetAppLabelId("appLabelId");
786 systemDefinedAppItem1.SetBundleName("bundleName");
787 systemDefinedAppItem1.SetAbilityName("abilityName");
788 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<SystemDefinedAppItem>(systemDefinedAppItem1);
789 data1.AddRecord(record1);
790 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
791 ASSERT_EQ(status, E_OK);
792
793 QueryOption option2 = { .key = key };
794 AddPrivilege(option2);
795 SetHapToken2();
796 UnifiedData data2;
797 status = UdmfClient::GetInstance().GetData(option2, data2);
798 ASSERT_EQ(status, E_OK);
799
800 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
801 ASSERT_NE(record2, nullptr);
802 auto type = record2->GetType();
803 ASSERT_EQ(type, UDType::SYSTEM_DEFINED_APP_ITEM);
804
805 auto systemDefinedRecord2 = static_cast<SystemDefinedRecord *>(record2.get());
806 ASSERT_NE(systemDefinedRecord2, nullptr);
807 CompareDetails(systemDefinedRecord2->GetDetails());
808
809 auto systemDefinedAppItem2 = static_cast<SystemDefinedAppItem *>(record2.get());
810 ASSERT_NE(systemDefinedAppItem2, nullptr);
811 EXPECT_EQ(systemDefinedAppItem1.GetAppId(), systemDefinedAppItem2->GetAppId());
812 EXPECT_EQ(systemDefinedAppItem1.GetAppName(), systemDefinedAppItem2->GetAppName());
813 EXPECT_EQ(systemDefinedAppItem1.GetBundleName(), systemDefinedAppItem2->GetBundleName());
814 EXPECT_EQ(systemDefinedAppItem1.GetAbilityName(), systemDefinedAppItem2->GetAbilityName());
815 EXPECT_EQ(systemDefinedAppItem1.GetAppIconId(), systemDefinedAppItem2->GetAppIconId());
816 EXPECT_EQ(systemDefinedAppItem1.GetAppLabelId(), systemDefinedAppItem2->GetAppLabelId());
817
818 GetEmptyData(option2);
819
820 LOG_INFO(UDMF_TEST, "SetData013 end.");
821 }
822
823 /**
824 * @tc.name: SetData014
825 * @tc.desc: Set PixelMap record with valid params and get data
826 * @tc.type: FUNC
827 */
828 HWTEST_F(UdmfClientTest, SetData014, TestSize.Level1)
829 {
830 LOG_INFO(UDMF_TEST, "SetData014 begin.");
831
832 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
833 UnifiedData data1;
834 std::string key;
835 SystemDefinedPixelMap systemDefinedPixelMap1;
836 UDDetails details1;
837 details1.insert({ "udmf_key", "udmf_value" });
838 systemDefinedPixelMap1.SetDetails(details1);
839 std::vector<uint8_t> rawData1 = { 1, 2, 3, 4, 5 };
840 systemDefinedPixelMap1.SetRawData(rawData1);
841 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<SystemDefinedPixelMap>(systemDefinedPixelMap1);
842 data1.AddRecord(record1);
843 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
844 ASSERT_EQ(status, E_OK);
845
846 QueryOption option2 = { .key = key };
847 AddPrivilege(option2);
848 SetHapToken2();
849 UnifiedData data2;
850 status = UdmfClient::GetInstance().GetData(option2, data2);
851 ASSERT_EQ(status, E_OK);
852
853 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
854 ASSERT_NE(record2, nullptr);
855 auto type = record2->GetType();
856 ASSERT_EQ(type, UDType::SYSTEM_DEFINED_PIXEL_MAP);
857
858 auto systemDefinedRecord2 = static_cast<SystemDefinedRecord *>(record2.get());
859 ASSERT_NE(systemDefinedRecord2, nullptr);
860 CompareDetails(systemDefinedRecord2->GetDetails());
861
862 auto systemDefinedPixelMap2 = static_cast<SystemDefinedPixelMap *>(record2.get());
863 ASSERT_NE(systemDefinedPixelMap2, nullptr);
864 auto rawData2 = systemDefinedPixelMap2->GetRawData();
865 EXPECT_EQ(rawData1.size(), rawData2.size());
866 for (uint32_t i = 0; i < rawData1.size(); ++i) {
867 EXPECT_EQ(rawData1[i], rawData2[i]);
868 }
869
870 GetEmptyData(option2);
871
872 LOG_INFO(UDMF_TEST, "SetData014 end.");
873 }
874
875 /**
876 * @tc.name: SetData015
877 * @tc.desc: Set Application Defined record with valid params and get data
878 * @tc.type: FUNC
879 */
880 HWTEST_F(UdmfClientTest, SetData015, TestSize.Level1)
881 {
882 LOG_INFO(UDMF_TEST, "SetData015 begin.");
883
884 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
885 UnifiedData data1;
886 std::string key;
887 ApplicationDefinedRecord applicationDefinedRecord1;
888 applicationDefinedRecord1.SetApplicationDefinedType("applicationDefinedType");
889 std::vector<uint8_t> rawData1 = { 1, 2, 3, 4, 5 };
890 applicationDefinedRecord1.SetRawData(rawData1);
891 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<ApplicationDefinedRecord>(applicationDefinedRecord1);
892 data1.AddRecord(record1);
893 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
894 ASSERT_EQ(status, E_OK);
895
896 QueryOption option2 = { .key = key };
897 AddPrivilege(option2);
898 SetHapToken2();
899 UnifiedData data2;
900 status = UdmfClient::GetInstance().GetData(option2, data2);
901 ASSERT_EQ(status, E_OK);
902
903 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
904 ASSERT_NE(record2, nullptr);
905 auto type = record2->GetType();
906 ASSERT_EQ(type, UDType::APPLICATION_DEFINED_RECORD);
907
908 auto applicationDefinedRecord2 = static_cast<ApplicationDefinedRecord *>(record2.get());
909 ASSERT_NE(applicationDefinedRecord2, nullptr);
910 EXPECT_EQ(applicationDefinedRecord1.GetApplicationDefinedType(),
911 applicationDefinedRecord2->GetApplicationDefinedType());
912 auto rawData2 = applicationDefinedRecord2->GetRawData();
913 EXPECT_EQ(rawData1.size(), rawData2.size());
914 for (uint32_t i = 0; i < rawData1.size(); ++i) {
915 EXPECT_EQ(rawData1[i], rawData2[i]);
916 }
917
918 GetEmptyData(option2);
919
920 LOG_INFO(UDMF_TEST, "SetData015 end.");
921 }
922
923 /**
924 * @tc.name: SetData016
925 * @tc.desc: Set multiple record with valid params and get data
926 * @tc.type: FUNC
927 */
928 HWTEST_F(UdmfClientTest, SetData016, TestSize.Level1)
929 {
930 LOG_INFO(UDMF_TEST, "SetData016 begin.");
931
932 CustomOption customOption = {.intention = Intention::UD_INTENTION_DRAG};
933 std::string key;
934 UnifiedData inputData;
935 std::vector<std::shared_ptr<UnifiedRecord>> inputRecords = {
936 std::make_shared<Text>(),
937 std::make_shared<PlainText>(),
938 std::make_shared<File>(),
939 std::make_shared<Image>(),
940 std::make_shared<SystemDefinedRecord>(),
941 std::make_shared<SystemDefinedForm>(),
942 std::make_shared<ApplicationDefinedRecord>()
943 };
944 inputData.SetRecords(inputRecords);
945
946 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
947 ASSERT_EQ(status, E_OK);
948
949 QueryOption queryOption = { .key = key };
950 UnifiedData outputData;
951 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
952 ASSERT_EQ(status, E_OK);
953 auto outputRecords = outputData.GetRecords();
954 ASSERT_EQ(inputRecords.size(), outputRecords.size());
955 for (size_t i = 0; i < outputRecords.size(); ++i) {
956 ASSERT_EQ(outputRecords[i]->GetType(), inputRecords[i]->GetType());
957 }
958
959 LOG_INFO(UDMF_TEST, "SetData016 end.");
960 }
961
962 /**
963 * @tc.name: SetData017
964 * @tc.desc: Set 512 records with valid params and get data
965 * @tc.type: FUNC
966 */
967 HWTEST_F(UdmfClientTest, SetData017, TestSize.Level1)
968 {
969 LOG_INFO(UDMF_TEST, "SetData017 begin.");
970
971 CustomOption customOption = {.intention = Intention::UD_INTENTION_DRAG};
972 std::string key;
973 UnifiedData inputData;
974 std::vector<std::shared_ptr<UnifiedRecord>> inputRecords;
975 for (int32_t i = 0; i < 512; ++i) {
976 inputRecords.emplace_back(std::make_shared<Text>());
977 }
978 inputData.SetRecords(inputRecords);
979
980 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
981 ASSERT_EQ(status, E_OK);
982
983 QueryOption queryOption = { .key = key };
984 UnifiedData outputData;
985 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
986 ASSERT_EQ(status, E_OK);
987 auto outputRecords = outputData.GetRecords();
988 ASSERT_EQ(inputRecords.size(), outputRecords.size());
989
990 LOG_INFO(UDMF_TEST, "SetData017 end.");
991 }
992
993 /**
994 * @tc.name: SetData018
995 * @tc.desc: Set one 2MB record of data with valid params and get data
996 * @tc.type: FUNC
997 */
998 HWTEST_F(UdmfClientTest, SetData018, TestSize.Level1)
999 {
1000 LOG_INFO(UDMF_TEST, "SetData018 begin.");
1001
1002 CustomOption customOption = { .intention = Intention::UD_INTENTION_DRAG };
1003 UnifiedData inputData;
1004 std::string key;
1005 UDDetails details;
1006 std::string value;
1007 int64_t maxSize = 512 * 1024;
1008 for (int64_t i = 0; i < maxSize; ++i) {
1009 value += "11";
1010 }
1011 details.insert({ value, value });
1012 Text text;
1013 text.SetDetails(details);
1014 std::shared_ptr<UnifiedRecord> record = std::make_shared<Text>(text);
1015 inputData.AddRecord(record);
1016
1017 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
1018 ASSERT_EQ(status, E_OK);
1019
1020 QueryOption queryOption = { .key = key };
1021 UnifiedData outputData;
1022 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
1023 ASSERT_EQ(status, E_OK);
1024
1025 LOG_INFO(UDMF_TEST, "SetData018 end.");
1026 }
1027
1028 /**
1029 * @tc.name: SetData019
1030 * @tc.desc: Set one over 4MB record of data with valid params and get data
1031 * @tc.type: FUNC
1032 */
1033 HWTEST_F(UdmfClientTest, SetData019, TestSize.Level1)
1034 {
1035 LOG_INFO(UDMF_TEST, "SetData019 begin.");
1036
1037 CustomOption customOption = { .intention = Intention::UD_INTENTION_DRAG };
1038 UnifiedData inputData;
1039 std::string key;
1040 UDDetails details;
1041 std::string value;
1042 int64_t maxSize = 512 * 1024;
1043 for (int64_t i = 0; i < maxSize; ++i) {
1044 value += "1111";
1045 }
1046 details.insert({ value, value });
1047 details.insert({ "udmf_key", "udmf_value" });
1048 Text text;
1049 text.SetDetails(details);
1050 std::shared_ptr<UnifiedRecord> record = std::make_shared<Text>(text);
1051 inputData.AddRecord(record);
1052
1053 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
1054 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1055
1056 LOG_INFO(UDMF_TEST, "SetData019 end.");
1057 }
1058
1059 /**
1060 * @tc.name: SetData020
1061 * @tc.desc: Set two 2MB record of data with valid params and get data
1062 * @tc.type: FUNC
1063 */
1064 HWTEST_F(UdmfClientTest, SetData020, TestSize.Level1)
1065 {
1066 LOG_INFO(UDMF_TEST, "SetData020 begin.");
1067
1068 CustomOption customOption = { .intention = Intention::UD_INTENTION_DRAG };
1069 UnifiedData inputData;
1070 std::string key;
1071 UDDetails details;
1072 std::string value;
1073 int64_t maxSize = 512 * 1024;
1074 for (int64_t i = 0; i < maxSize; ++i) {
1075 value += "11";
1076 }
1077 details.insert({ value, value });
1078 Text text;
1079 text.SetDetails(details);
1080 std::shared_ptr<UnifiedRecord> record = std::make_shared<Text>(text);
1081 for (int i = 0; i < 2; ++i) {
1082 inputData.AddRecord(record);
1083 }
1084 auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
1085 ASSERT_EQ(status, E_OK);
1086
1087 QueryOption queryOption = { .key = key };
1088 UnifiedData outputData;
1089 status = UdmfClient::GetInstance().GetData(queryOption, outputData);
1090 ASSERT_EQ(status, E_OK);
1091
1092 LOG_INFO(UDMF_TEST, "SetData020 end.");
1093 }
1094
1095 /**
1096 * @tc.name: GetData001
1097 * @tc.desc: Get data with invalid key
1098 * @tc.type: FUNC
1099 */
1100 HWTEST_F(UdmfClientTest, GetData001, TestSize.Level1)
1101 {
1102 LOG_INFO(UDMF_TEST, "GetData001 begin.");
1103
1104 QueryOption option;
1105 UnifiedData data;
1106 auto status = UdmfClient::GetInstance().GetData(option, data);
1107 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1108
1109 option.key = "udmf";
1110 status = UdmfClient::GetInstance().GetData(option, data);
1111 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1112
1113 option.key = "odmf://";
1114 status = UdmfClient::GetInstance().GetData(option, data);
1115 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1116
1117 option.key = "udmf://drag";
1118 status = UdmfClient::GetInstance().GetData(option, data);
1119 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1120
1121 option.key = "udmf://123/bundle/group";
1122 status = UdmfClient::GetInstance().GetData(option, data);
1123 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1124
1125 option.key = "udmf://drag/bundle";
1126 status = UdmfClient::GetInstance().GetData(option, data);
1127 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1128
1129 option.key = "udmf://drag/bundle***/group";
1130 status = UdmfClient::GetInstance().GetData(option, data);
1131 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1132
1133 option.key = "udmf://drag/bundle/";
1134 status = UdmfClient::GetInstance().GetData(option, data);
1135 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1136
1137 option.key = "udmf://drag/bundle/group###";
1138 status = UdmfClient::GetInstance().GetData(option, data);
1139 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1140
1141 LOG_INFO(UDMF_TEST, "GetData001 end.");
1142 }
1143
1144 /**
1145 * @tc.name: GetSummary001
1146 * @tc.desc: Get summary data
1147 * @tc.type: FUNC
1148 */
1149 HWTEST_F(UdmfClientTest, GetSummary001, TestSize.Level1)
1150 {
1151 LOG_INFO(UDMF_TEST, "GetSummary001 begin.");
1152
1153 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
1154 UnifiedData data;
1155 std::string key;
1156
1157 UDDetails details;
1158 details.insert({ "udmf_key", "udmf_value" });
1159
1160 Text text;
1161 text.SetDetails(details);
1162 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<Text>(text);
1163 data.AddRecord(record1);
1164
1165 PlainText plainText;
1166 plainText.SetDetails(details);
1167 plainText.SetContent("content");
1168 plainText.SetAbstract("abstract");
1169 std::shared_ptr<UnifiedRecord> record2 = std::make_shared<PlainText>(plainText);
1170 data.AddRecord(record2);
1171
1172 File file;
1173 file.SetDetails(details);
1174 file.SetUri("uri");
1175 file.SetRemoteUri("remoteUri");
1176 std::shared_ptr<UnifiedRecord> record3 = std::make_shared<File>(file);
1177 data.AddRecord(record3);
1178
1179 Image image;
1180 file.SetDetails(details);
1181 image.SetUri("uri");
1182 image.SetRemoteUri("remoteUri");
1183 std::shared_ptr<UnifiedRecord> record4 = std::make_shared<Image>(image);
1184 data.AddRecord(record4);
1185
1186 SystemDefinedRecord systemDefinedRecord;
1187 systemDefinedRecord.SetDetails(details);
1188 std::shared_ptr<UnifiedRecord> record5 = std::make_shared<SystemDefinedRecord>(systemDefinedRecord);
1189 data.AddRecord(record5);
1190
1191 SystemDefinedForm systemDefinedForm;
1192 systemDefinedForm.SetDetails(details);
1193 systemDefinedForm.SetFormId(123);
1194 systemDefinedForm.SetFormName("formName");
1195 systemDefinedForm.SetModule("module");
1196 systemDefinedForm.SetAbilityName("abilityName");
1197 systemDefinedForm.SetBundleName("bundleName");
1198 std::shared_ptr<UnifiedRecord> record6 = std::make_shared<SystemDefinedForm>(systemDefinedForm);
1199 data.AddRecord(record6);
1200
1201 ApplicationDefinedRecord applicationDefinedRecord;
1202 applicationDefinedRecord.SetApplicationDefinedType("applicationDefinedType");
1203 std::vector<uint8_t> rawData = { 1, 2, 3, 4, 5 };
1204 applicationDefinedRecord.SetRawData(rawData);
1205 std::shared_ptr<UnifiedRecord> record7 = std::make_shared<ApplicationDefinedRecord>(applicationDefinedRecord);
1206 data.AddRecord(record7);
1207
1208 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
1209 ASSERT_EQ(status, E_OK);
1210
1211 QueryOption option2 = { .key = key };
1212 Summary summary;
1213 status = UdmfClient::GetInstance().GetSummary(option2, summary);
1214
1215 auto size = record1->GetSize();
1216 size += record2->GetSize();
1217 size += record3->GetSize();
1218 size += record4->GetSize();
1219 size += record5->GetSize();
1220 size += record6->GetSize();
1221 size += record7->GetSize();
1222
1223 ASSERT_EQ(status, E_OK);
1224 ASSERT_EQ(summary.totalSize, size);
1225 ASSERT_EQ(summary.summary["general.text"], record1->GetSize());
1226 ASSERT_EQ(summary.summary["general.plain-text"], record2->GetSize());
1227 ASSERT_EQ(summary.summary["general.file"], record3->GetSize());
1228 ASSERT_EQ(summary.summary["general.image"], record4->GetSize());
1229 ASSERT_EQ(summary.summary["SystemDefinedType"], record5->GetSize());
1230 ASSERT_EQ(summary.summary["openharmony.form"], record6->GetSize());
1231 ASSERT_EQ(summary.summary["ApplicationDefinedType"], record7->GetSize());
1232
1233 LOG_INFO(UDMF_TEST, "GetSummary001 end.");
1234 }
1235
1236
1237 /**
1238 * @tc.name: GetSummary002
1239 * @tc.desc: Get summary with invalid key
1240 * @tc.type: FUNC
1241 */
1242 HWTEST_F(UdmfClientTest, GetSummary002, TestSize.Level1)
1243 {
1244 LOG_INFO(UDMF_FRAMEWORK, "GetSummary002 begin.");
1245
1246 QueryOption option;
1247 Summary summary;
1248 auto status = UdmfClient::GetInstance().GetSummary(option, summary);
1249 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1250
1251 option.key = "udmf";
1252 status = UdmfClient::GetInstance().GetSummary(option, summary);
1253 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1254
1255 option.key = "odmf://";
1256 status = UdmfClient::GetInstance().GetSummary(option, summary);
1257 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1258
1259 option.key = "udmf://drag";
1260 status = UdmfClient::GetInstance().GetSummary(option, summary);
1261 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1262
1263 option.key = "udmf://123/bundle/group";
1264 status = UdmfClient::GetInstance().GetSummary(option, summary);
1265 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1266
1267 option.key = "udmf://drag/bundle";
1268 status = UdmfClient::GetInstance().GetSummary(option, summary);
1269 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1270
1271 option.key = "udmf://drag/bundle***/group";
1272 status = UdmfClient::GetInstance().GetSummary(option, summary);
1273 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1274
1275 option.key = "udmf://drag/bundle/";
1276 status = UdmfClient::GetInstance().GetSummary(option, summary);
1277 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1278
1279 option.key = "udmf://drag/bundle/group###";
1280 status = UdmfClient::GetInstance().GetSummary(option, summary);
1281 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1282
1283 LOG_INFO(UDMF_FRAMEWORK, "GetSummary002 end.");
1284 }
1285
1286 /**
1287 * @tc.name: AddPrivilege001
1288 * @tc.desc: Add privilege with valid params
1289 * @tc.type: FUNC
1290 */
1291 HWTEST_F(UdmfClientTest, AddPrivilege001, TestSize.Level1)
1292 {
1293 LOG_INFO(UDMF_TEST, "AddPrivilege001 begin.");
1294
1295 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
1296 UnifiedData data;
1297 Text text;
1298 UDDetails details;
1299 details.insert({ "udmf_key", "udmf_value" });
1300 text.SetDetails(details);
1301 std::shared_ptr<UnifiedRecord> record = std::make_shared<Text>(text);
1302 data.AddRecord(record);
1303 std::string key;
1304 auto status = UdmfClient::GetInstance().SetData(option1, data, key);
1305 ASSERT_EQ(status, E_OK);
1306
1307 QueryOption option2 = { .key = key };
1308 Privilege privilege;
1309 SetHapToken2();
1310 privilege.tokenId = AccessTokenKit::GetHapTokenID(100, "ohos.test.demo2", 0);
1311 privilege.readPermission = "readPermission";
1312 privilege.writePermission = "writePermission";
1313 SetNativeToken();
1314 status = UdmfClient::GetInstance().AddPrivilege(option2, privilege);
1315 ASSERT_EQ(status, E_OK);
1316
1317 LOG_INFO(UDMF_TEST, "AddPrivilege001 end.");
1318 }
1319
1320 /**
1321 * @tc.name: AddPrivilege002
1322 * @tc.desc: Add Privilege with invalid params
1323 * @tc.type: FUNC
1324 */
1325 HWTEST_F(UdmfClientTest, AddPrivilege002, TestSize.Level1)
1326 {
1327 LOG_INFO(UDMF_FRAMEWORK, "AddPrivilege002 begin.");
1328
1329 QueryOption option;
1330 Privilege privilege;
1331 auto status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1332 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1333
1334 option.key = "udmf";
1335 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1336 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1337
1338 option.key = "odmf://";
1339 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1340 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1341
1342 option.key = "udmf://drag";
1343 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1344 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1345
1346 option.key = "udmf://123/bundle/group";
1347 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1348 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1349
1350 option.key = "udmf://drag/bundle";
1351 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1352 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1353
1354 option.key = "udmf://drag/bundle***/group";
1355 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1356 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1357
1358 option.key = "udmf://drag/bundle/";
1359 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1360 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1361
1362 option.key = "udmf://drag/bundle/group###";
1363 status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
1364 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1365
1366 LOG_INFO(UDMF_FRAMEWORK, "AddPrivilege002 end.");
1367 }
1368
1369 /**
1370 * @tc.name: GetSelfData001
1371 * @tc.desc: Set File record with valid params and no add privilege and get data by self
1372 * @tc.type: FUNC
1373 */
1374 HWTEST_F(UdmfClientTest, GetSelfData001, TestSize.Level1)
1375 {
1376 LOG_INFO(UDMF_TEST, "GetSelfData001 begin.");
1377
1378 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
1379 UnifiedData data1;
1380 std::string key;
1381 File file1;
1382 file1.SetRemoteUri("remoteUri");
1383 UDDetails details1;
1384 details1.insert({ "udmf_key", "udmf_value" });
1385 file1.SetDetails(details1);
1386 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<File>(file1);
1387 data1.AddRecord(record1);
1388 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
1389 ASSERT_EQ(status, E_OK);
1390
1391 QueryOption option2 = { .key = key };
1392 UnifiedData data2;
1393 status = UdmfClient::GetInstance().GetData(option2, data2);
1394 ASSERT_EQ(status, E_OK);
1395
1396 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
1397 ASSERT_NE(record2, nullptr);
1398 auto type = record2->GetType();
1399 ASSERT_EQ(type, UDType::FILE);
1400
1401 auto file2 = static_cast<File *>(record2.get());
1402 ASSERT_NE(file2, nullptr);
1403 EXPECT_EQ(file1.GetRemoteUri(), file2->GetRemoteUri());
1404 CompareDetails(file2->GetDetails());
1405
1406 GetEmptyData(option2);
1407
1408 LOG_INFO(UDMF_TEST, "GetSelfData001 end.");
1409 }
1410
1411 /**
1412 * @tc.name: GetSelfData002
1413 * @tc.desc: Set File record with valid params and add privilege and get data by self
1414 * @tc.type: FUNC
1415 */
1416 HWTEST_F(UdmfClientTest, GetSelfData002, TestSize.Level1)
1417 {
1418 LOG_INFO(UDMF_TEST, "GetSelfData002 begin.");
1419
1420 CustomOption option1 = { .intention = Intention::UD_INTENTION_DRAG };
1421 UnifiedData data1;
1422 std::string key;
1423 File file1;
1424 file1.SetRemoteUri("remoteUri");
1425 UDDetails details1;
1426 details1.insert({ "udmf_key", "udmf_value" });
1427 file1.SetDetails(details1);
1428 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<File>(file1);
1429 data1.AddRecord(record1);
1430 auto status = UdmfClient::GetInstance().SetData(option1, data1, key);
1431 ASSERT_EQ(status, E_OK);
1432
1433 QueryOption option2 = { .key = key };
1434 AddPrivilege(option2);
1435 SetHapToken1();
1436 UnifiedData data2;
1437 status = UdmfClient::GetInstance().GetData(option2, data2);
1438 ASSERT_EQ(status, E_OK);
1439
1440 std::shared_ptr<UnifiedRecord> record2 = data2.GetRecordAt(0);
1441 ASSERT_NE(record2, nullptr);
1442 auto type = record2->GetType();
1443 ASSERT_EQ(type, UDType::FILE);
1444
1445 auto file2 = static_cast<File *>(record2.get());
1446 ASSERT_NE(file2, nullptr);
1447 EXPECT_EQ(file1.GetRemoteUri(), file2->GetRemoteUri());
1448 CompareDetails(file2->GetDetails());
1449
1450 GetEmptyData(option2);
1451
1452 LOG_INFO(UDMF_TEST, "GetSelfData002 end.");
1453 }
1454
1455 /**
1456 * @tc.name: SetData021
1457 * @tc.desc: Set datas with intention ${UD_INTENTION_DATA_HUB} and manually check db is cleared before set or not
1458 * @tc.type: FUNC
1459 */
1460 HWTEST_F(UdmfClientTest, SetData021, TestSize.Level1)
1461 {
1462 LOG_INFO(UDMF_TEST, "SetData021 begin.");
1463 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
1464 std::vector<UnifiedData> unifiedDataSet;
1465 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
1466 ASSERT_EQ(status, E_OK);
1467 unifiedDataSet.clear();
1468 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
1469 ASSERT_EQ(status, E_OK);
1470 ASSERT_TRUE(unifiedDataSet.empty());
1471
1472 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
1473 UnifiedData data1;
1474 PlainText plainText1;
1475 plainText1.SetContent("content1");
1476 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<PlainText>(plainText1);
1477 data1.AddRecord(record1);
1478 std::string key;
1479 status = UdmfClient::GetInstance().SetData(customOption, data1, key);
1480 ASSERT_EQ(status, E_OK);
1481
1482 UnifiedData data2;
1483 PlainText plainText2;
1484 plainText1.SetContent("content2");
1485 std::shared_ptr<UnifiedRecord> record2 = std::make_shared<PlainText>(plainText1);
1486 data2.AddRecord(record2);
1487 status = UdmfClient::GetInstance().SetData(customOption, data2, key);
1488 ASSERT_EQ(status, E_OK);
1489
1490 SetHapToken2();
1491 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
1492 ASSERT_EQ(status, E_OK);
1493 auto size = static_cast<int32_t>(unifiedDataSet.size());
1494 ASSERT_EQ(size, 2);
1495 LOG_INFO(UDMF_TEST, "SetData021 end.");
1496 }
1497
1498 /**
1499 * @tc.name: UpdateData001
1500 * @tc.desc: Update data with invalid params
1501 * @tc.type: FUNC
1502 */
1503 HWTEST_F(UdmfClientTest, UpdateData001, TestSize.Level1)
1504 {
1505 LOG_INFO(UDMF_TEST, "UpdateData001 begin.");
1506
1507 UnifiedData data;
1508 QueryOption queryOption = { .key = "" };
1509 auto status = UdmfClient::GetInstance().UpdateData(queryOption, data);
1510 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1511
1512 queryOption = { .key = "udmf://drag/ohos.test.demo1/abcde" };
1513 status = UdmfClient::GetInstance().UpdateData(queryOption, data);
1514 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1515
1516 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
1517 UnifiedData data1;
1518 PlainText plainText1;
1519 plainText1.SetContent("content1");
1520 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<PlainText>(plainText1);
1521 data1.AddRecord(record1);
1522 std::string key;
1523 status = UdmfClient::GetInstance().SetData(customOption, data1, key);
1524 ASSERT_EQ(status, E_OK);
1525
1526 queryOption = { .key = key };
1527 SetHapToken2();
1528 status = UdmfClient::GetInstance().UpdateData(queryOption, data);
1529 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1530 LOG_INFO(UDMF_TEST, "UpdateData001 end.");
1531 }
1532
1533 /**
1534 * @tc.name: UpdateData002
1535 * @tc.desc: Update data with valid params
1536 * @tc.type: FUNC
1537 */
1538 HWTEST_F(UdmfClientTest, UpdateData002, TestSize.Level1)
1539 {
1540 LOG_INFO(UDMF_TEST, "UpdateData002 begin.");
1541
1542 UnifiedData data;
1543 PlainText plainText;
1544 plainText.SetContent("content");
1545 std::shared_ptr<UnifiedRecord> record = std::make_shared<PlainText>(plainText);
1546 data.AddRecord(record);
1547
1548 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
1549 UnifiedData data1;
1550 PlainText plainText1;
1551 plainText1.SetContent("content1");
1552 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<PlainText>(plainText1);
1553 data1.AddRecord(record1);
1554 std::string key;
1555 auto status = UdmfClient::GetInstance().SetData(customOption, data1, key);
1556
1557 ASSERT_EQ(status, E_OK);
1558 QueryOption queryOption = { .key = key };
1559 SetHapToken2();
1560 status = UdmfClient::GetInstance().UpdateData(queryOption, data);
1561 ASSERT_EQ(status, E_OK);
1562
1563 std::vector<UnifiedData> dataSet;
1564 status = UdmfClient::GetInstance().GetBatchData(queryOption, dataSet);
1565 std::shared_ptr<UnifiedRecord> record2 = dataSet[0].GetRecordAt(0);
1566 ASSERT_NE(record2, nullptr);
1567 auto type = record2->GetType();
1568 ASSERT_EQ(type, UDType::PLAIN_TEXT);
1569 auto plainText2 = static_cast<PlainText *>(record2.get());
1570 ASSERT_EQ(plainText2->GetContent(), "content");
1571
1572 LOG_INFO(UDMF_TEST, "UpdateData002 end.");
1573 }
1574
1575 /**
1576 * @tc.name: QueryData001
1577 * @tc.desc: Query data with invalid params
1578 * @tc.type: FUNC
1579 */
1580 HWTEST_F(UdmfClientTest, QueryData001, TestSize.Level1)
1581 {
1582 LOG_INFO(UDMF_TEST, "QueryData001 begin.");
1583 std::vector<UnifiedData> unifiedDataSet;
1584 QueryOption queryOption = {};
1585 auto status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1586 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1587
1588 queryOption = { .key = "udmf://drag/ohos.test.demo1/abcde" };
1589 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1590 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1591
1592 queryOption = { .intention = UD_INTENTION_DRAG };
1593 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1594 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1595
1596 queryOption = { .key = "udmf://DataHub/ohos.test.demo1/abcde", .intention = UD_INTENTION_DRAG };
1597 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1598 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1599
1600 queryOption = { .key = "udmf://drag/ohos.test.demo1/abcde", .intention = UD_INTENTION_DATA_HUB };
1601 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1602 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1603 LOG_INFO(UDMF_TEST, "QueryData001 end.");
1604 }
1605
1606 /**
1607 * @tc.name: QueryData002
1608 * @tc.desc: Query data with valid params
1609 * @tc.type: FUNC
1610 */
1611 HWTEST_F(UdmfClientTest, QueryData002, TestSize.Level1)
1612 {
1613 LOG_INFO(UDMF_TEST, "QueryData002 begin.");
1614
1615 QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
1616 std::vector<UnifiedData> unifiedDataSet;
1617 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
1618 ASSERT_EQ(status, E_OK);
1619 unifiedDataSet.clear();
1620 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
1621 ASSERT_EQ(status, E_OK);
1622 ASSERT_TRUE(unifiedDataSet.empty());
1623
1624 CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
1625 UnifiedData data;
1626 PlainText plainText;
1627 plainText.SetContent("content1");
1628 std::shared_ptr<UnifiedRecord> record = std::make_shared<PlainText>(plainText);
1629 data.AddRecord(record);
1630 std::string key;
1631 status = UdmfClient::GetInstance().SetData(customOption, data, key);
1632 ASSERT_EQ(status, E_OK);
1633
1634 query = { .key = key };
1635 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
1636 ASSERT_EQ(status, E_OK);
1637 auto size = static_cast<int32_t>(unifiedDataSet.size());
1638 ASSERT_EQ(size, 1);
1639 std::shared_ptr<UnifiedRecord> record2 = unifiedDataSet[0].GetRecordAt(0);
1640 ASSERT_NE(record2, nullptr);
1641 auto type = record2->GetType();
1642 ASSERT_EQ(type, UDType::PLAIN_TEXT);
1643 auto plainText2 = static_cast<PlainText *>(record2.get());
1644 ASSERT_EQ(plainText2->GetContent(), "content1");
1645
1646 UnifiedData data2;
1647 plainText.SetContent("content2");
1648 record = std::make_shared<PlainText>(plainText);
1649 data2.AddRecord(record);
1650 status = UdmfClient::GetInstance().SetData(customOption, data2, key);
1651 ASSERT_EQ(status, E_OK);
1652
1653 unifiedDataSet.clear();
1654 query = { .key = key, .intention = UD_INTENTION_DATA_HUB };
1655 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
1656 ASSERT_EQ(status, E_OK);
1657 size = static_cast<int32_t>(unifiedDataSet.size());
1658 ASSERT_EQ(size, 1);
1659 record2 = unifiedDataSet[0].GetRecordAt(0);
1660 ASSERT_NE(record2, nullptr);
1661 type = record2->GetType();
1662 ASSERT_EQ(type, UDType::PLAIN_TEXT);
1663 plainText2 = static_cast<PlainText *>(record2.get());
1664 ASSERT_EQ(plainText2->GetContent(), "content2");
1665
1666 unifiedDataSet.clear();
1667 query = { .intention = UD_INTENTION_DATA_HUB };
1668 status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
1669 ASSERT_EQ(status, E_OK);
1670 size = static_cast<int32_t>(unifiedDataSet.size());
1671 ASSERT_EQ(size, 2);
1672
1673 LOG_INFO(UDMF_TEST, "QueryData002 end.");
1674 }
1675
1676 /**
1677 * @tc.name: DeleteData001
1678 * @tc.desc: Delete data with invalid params
1679 * @tc.type: FUNC
1680 */
1681 HWTEST_F(UdmfClientTest, DeleteData001, TestSize.Level1)
1682 {
1683 LOG_INFO(UDMF_TEST, "DeleteData001 begin.");
1684 std::vector<UnifiedData> unifiedDataSet;
1685 QueryOption queryOption = {};
1686 auto status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
1687 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1688
1689 queryOption = { .key = "udmf://drag/ohos.test.demo1/abcde" };
1690 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
1691 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1692
1693 queryOption = { .intention = UD_INTENTION_DRAG };
1694 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
1695 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1696
1697 queryOption = { .key = "udmf://DataHub/ohos.test.demo1/abcde", .intention = UD_INTENTION_DRAG };
1698 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
1699 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1700
1701 queryOption = { .key = "udmf://drag/ohos.test.demo1/abcde", .intention = UD_INTENTION_DATA_HUB };
1702 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
1703 ASSERT_EQ(status, E_INVALID_PARAMETERS);
1704 LOG_INFO(UDMF_TEST, "DeleteData001 end.");
1705 }
1706
1707 /**
1708 * @tc.name: DeleteData002
1709 * @tc.desc: Delete data with valid params
1710 * @tc.type: FUNC
1711 */
1712 HWTEST_F(UdmfClientTest, DeleteData002, TestSize.Level1)
1713 {
1714 LOG_INFO(UDMF_TEST, "DeleteData002 begin.");
1715
1716 CustomOption customOption = { .intention = UD_INTENTION_DATA_HUB };
1717 UnifiedData data;
1718 PlainText plainText;
1719 plainText.SetContent("content1");
1720 std::shared_ptr<UnifiedRecord> record = std::make_shared<PlainText>(plainText);
1721 data.AddRecord(record);
1722 std::string key;
1723 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
1724 ASSERT_EQ(status, E_OK);
1725 status = UdmfClient::GetInstance().SetData(customOption, data, key);
1726 ASSERT_EQ(status, E_OK);
1727 status = UdmfClient::GetInstance().SetData(customOption, data, key);
1728 ASSERT_EQ(status, E_OK);
1729
1730 QueryOption queryOption = { .key = key };
1731 SetHapToken2();
1732
1733 std::vector<UnifiedData> unifiedDataSet;
1734 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
1735 ASSERT_EQ(status, E_OK);
1736
1737 unifiedDataSet.clear();
1738 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1739 ASSERT_TRUE(unifiedDataSet.empty());
1740
1741 queryOption = { .intention = UD_INTENTION_DATA_HUB };
1742 unifiedDataSet.clear();
1743 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1744 ASSERT_TRUE(!unifiedDataSet.empty());
1745
1746 status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
1747 ASSERT_EQ(status, E_OK);
1748
1749 unifiedDataSet.clear();
1750 status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
1751 ASSERT_TRUE(unifiedDataSet.empty());
1752 LOG_INFO(UDMF_TEST, "DeleteData002 end.");
1753 }
1754 } // OHOS::Test