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