1 /*
2 * Copyright (c) 2025 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 "UdmfDelayDataTest"
16 #include <gtest/gtest.h>
17
18 #include "accesstoken_kit.h"
19 #include "nativetoken_kit.h"
20 #include "token_setproc.h"
21 #include "async_task_params.h"
22 #include "data_params_conversion.h"
23 #include "logger.h"
24 #include "plain_text.h"
25 #include "udmf.h"
26 #include "udmf_async_client.h"
27 #include "udmf_client.h"
28 #include "udmf_executor.h"
29 #include "udmf_utils.h"
30
31 using namespace testing::ext;
32 using namespace OHOS::Security::AccessToken;
33 using namespace OHOS::UDMF;
34 using namespace OHOS;
35 namespace OHOS::Test {
36 static constexpr int USER_ID = 100;
37 static constexpr int END_INTERVAL = 3;
38 class UdmfDelayDataTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp() override;
43 void TearDown() override;
44
45 static void AllocHapToken1();
46 static void AllocHapToken2();
47 static void SetHapToken1();
48 static void SetHapToken2();
49 static void AddPrivilege(QueryOption &option);
50 static void SetNativeToken(const std::string &processName);
51 static std::string SetDataInfoTest(const std::string &key);
52 static void GetDelayDataTest(const std::string &key);
53 static std::string NdkSetDataInfoTest();
54 static void NdkGetDelayDataTest(const std::string &key);
55 };
56
SetUpTestCase()57 void UdmfDelayDataTest::SetUpTestCase()
58 {
59 AllocHapToken1();
60 AllocHapToken2();
61 }
62
TearDownTestCase()63 void UdmfDelayDataTest::TearDownTestCase()
64 {
65 std::this_thread::sleep_for(std::chrono::seconds(END_INTERVAL));
66 std::vector<UnifiedData> unifiedDataSet;
67 QueryOption query = {
68 .intention = UDMF::UD_INTENTION_DATA_HUB
69 };
70 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
71 EXPECT_EQ(E_OK, status);
72
73 auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo1", 0);
74 AccessTokenKit::DeleteToken(tokenId);
75 auto tokenId2 = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo2", 0);
76 AccessTokenKit::DeleteToken(tokenId2);
77 }
78
SetUp()79 void UdmfDelayDataTest::SetUp() {}
80
TearDown()81 void UdmfDelayDataTest::TearDown()
82 {
83 std::this_thread::sleep_for(std::chrono::seconds(END_INTERVAL));
84 }
85
AllocHapToken1()86 void UdmfDelayDataTest::AllocHapToken1()
87 {
88 HapInfoParams info = {
89 .userID = USER_ID,
90 .bundleName = "ohos.test.demo1",
91 .instIndex = 0,
92 .isSystemApp = false,
93 .appIDDesc = "ohos.test.demo1"
94 };
95 HapPolicyParams policy = {
96 .apl = APL_SYSTEM_BASIC,
97 .domain = "test.domain",
98 .permList = {
99 {
100 .permissionName = "ohos.permission.MANAGE_UDMF_APP_SHARE_OPTION",
101 .bundleName = "ohos.test.demo1",
102 .grantMode = 1,
103 .availableLevel = APL_SYSTEM_BASIC,
104 .label = "label",
105 .labelId = 1,
106 .description = "test2",
107 .descriptionId = 1
108 }
109 },
110 .permStateList = {
111 {
112 .permissionName = "ohos.permission.MANAGE_UDMF_APP_SHARE_OPTION",
113 .isGeneral = true,
114 .resDeviceID = { "local" },
115 .grantStatus = { PermissionState::PERMISSION_GRANTED },
116 .grantFlags = { 1 }
117 }
118 }
119 };
120 auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
121 SetSelfTokenID(tokenID.tokenIDEx);
122 }
123
AllocHapToken2()124 void UdmfDelayDataTest::AllocHapToken2()
125 {
126 HapInfoParams info = {
127 .userID = USER_ID,
128 .bundleName = "ohos.test.demo2",
129 .instIndex = 0,
130 .isSystemApp = false,
131 .appIDDesc = "ohos.test.demo2"
132 };
133
134 HapPolicyParams policy = {
135 .apl = APL_NORMAL,
136 .domain = "test.domain",
137 .permList = {
138 {
139 .permissionName = "ohos.permission.test",
140 .bundleName = "ohos.test.demo2",
141 .grantMode = 1,
142 .availableLevel = APL_NORMAL,
143 .label = "label",
144 .labelId = 1,
145 .description = "test2",
146 .descriptionId = 1
147 }
148 },
149 .permStateList = {
150 {
151 .permissionName = "ohos.permission.test",
152 .isGeneral = true,
153 .resDeviceID = { "local" },
154 .grantStatus = { PermissionState::PERMISSION_GRANTED },
155 .grantFlags = { 1 }
156 }
157 }
158 };
159 auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
160 SetSelfTokenID(tokenID.tokenIDEx);
161 }
162
SetHapToken1()163 void UdmfDelayDataTest::SetHapToken1()
164 {
165 auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo1", 0);
166 SetSelfTokenID(tokenId);
167 }
168
SetHapToken2()169 void UdmfDelayDataTest::SetHapToken2()
170 {
171 auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo2", 0);
172 SetSelfTokenID(tokenId);
173 }
174
SetNativeToken(const std::string & processName)175 void UdmfDelayDataTest::SetNativeToken(const std::string &processName)
176 {
177 auto tokenId = AccessTokenKit::GetNativeTokenId(processName);
178 SetSelfTokenID(tokenId);
179 }
180
AddPrivilege(QueryOption & option)181 void UdmfDelayDataTest::AddPrivilege(QueryOption &option)
182 {
183 Privilege privilege;
184 privilege.tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo2", 0);
185 privilege.readPermission = "readPermission";
186 privilege.writePermission = "writePermission";
187 SetNativeToken("msdp_sa");
188 auto status = UdmfClient::GetInstance().AddPrivilege(option, privilege);
189 ASSERT_EQ(status, E_OK);
190 }
191
192
193 /* *
194 * @tc.name: UdmfDelayDataTest001
195 * @tc.desc: Test get data success.
196 * @tc.type: FUNC
197 */
198 HWTEST_F(UdmfDelayDataTest, UdmfDelayDataTest001, TestSize.Level1)
199 {
200 LOG_INFO(UDMF_TEST, "UdmfDelayDataTest001 begin.");
201
202 DataLoadInfo dataLoadInfo1{
203 .recordCount = 10,
204 .types{"general.plain-text", "general.html"},
205 .sequenceKey = UTILS::GenerateId()
206 };
207 DataLoadInfo dataLoadInfo2{
208 .recordCount = 100,
209 .types{"general.plain-text"},
210 };
211
212 SetHapToken1();
__anon4bee1d940102(const std::string &udKey, const DataLoadInfo &dataLoadInfo) 213 auto loadHandler = [dataLoadInfo2] (const std::string &udKey, const DataLoadInfo &dataLoadInfo) {
214 LOG_INFO(UDMF_TEST, "loadHandler begin udKey=%{public}s.", udKey.c_str());
215 EXPECT_EQ(dataLoadInfo.recordCount, dataLoadInfo2.recordCount);
216 EXPECT_EQ(dataLoadInfo.types, dataLoadInfo2.types);
217 UnifiedData data;
218 auto obj = std::make_shared<Object>();
219 auto plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
220 plainText->SetContent("content1");
221 data.AddRecord(plainText);
222 auto ret = UdmfClient::GetInstance().PushDelayData(udKey, data);
223 EXPECT_EQ(ret, E_OK);
224 };
225 DataLoadParams dataLoadParams = {
226 .dataLoadInfo = dataLoadInfo1,
227 .loadHandler = loadHandler
228 };
229 std::string key = "";
230 auto status = UdmfClient::GetInstance().SetDelayInfo(dataLoadParams, key);
231 EXPECT_EQ(status, E_OK);
232
233 QueryOption option{
234 .intention = UD_INTENTION_DRAG,
235 .key = key
236 };
237 Summary summary;
238 status = UdmfClient::GetInstance().GetSummary(option, summary);
239 EXPECT_EQ(status, E_OK);
240 EXPECT_EQ(summary.totalSize, dataLoadInfo1.recordCount);
241 EXPECT_EQ(summary.summary.size(), dataLoadInfo1.types.size());
242 for (auto item: summary.summary) {
243 EXPECT_NE(summary.summary.find(item.first), summary.summary.end());
244 EXPECT_EQ(item.second, 0);
245 }
246
247 QueryOption query = {
248 .intention = UD_INTENTION_DRAG,
249 .key = key
250 };
251 AddPrivilege(query);
252
253 SetHapToken2();
__anon4bee1d940202(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 254 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
255 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d",
256 progress.progressStatus, progress.progress);
257 if (data == nullptr) {
258 ASSERT_TRUE(progress.progress != 0);
259 return;
260 }
261 ASSERT_EQ(1, data->GetRecords().size());
262 LOG_INFO(UDMF_TEST, "UdmfDelayDataTest001 callback end.");
263 };
264 GetDataParams params{
265 .query = query,
266 .progressIndicator = ProgressIndicator::DEFAULT,
267 .progressListener = callback,
268 .acceptableInfo = dataLoadInfo2,
269 };
270 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
271 EXPECT_EQ(status, E_OK);
272
273 LOG_INFO(UDMF_TEST, "UdmfDelayDataTest001 end.");
274 }
275
276 /* *
277 * @tc.name: UdmfDelayDataTest002
278 * @tc.desc: Test after waiting for 500ms, get data success.
279 * @tc.type: FUNC
280 */
281 HWTEST_F(UdmfDelayDataTest, UdmfDelayDataTest002, TestSize.Level1)
282 {
283 LOG_INFO(UDMF_TEST, "UdmfDelayDataTest002 begin.");
284
285 DataLoadInfo dataLoadInfo1{
286 .recordCount = 10,
287 .types{"general.plain-text", "general.html"},
288 .sequenceKey = UTILS::GenerateId()
289 };
290 DataLoadInfo dataLoadInfo2{
291 .recordCount = 100,
292 .types{"general.plain-text"},
293 };
294
295 SetHapToken1();
__anon4bee1d940302(const std::string &udKey, const DataLoadInfo &dataLoadInfo) 296 auto loadHandler = [dataLoadInfo2] (const std::string &udKey, const DataLoadInfo &dataLoadInfo) {
297 LOG_INFO(UDMF_TEST, "loadHandler begin udKey=%{public}s.", udKey.c_str());
298 EXPECT_EQ(dataLoadInfo.recordCount, dataLoadInfo2.recordCount);
299 EXPECT_EQ(dataLoadInfo.types, dataLoadInfo2.types);
300 std::this_thread::sleep_for(std::chrono::milliseconds(500));
301 UnifiedData data;
302 auto obj = std::make_shared<Object>();
303 auto plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
304 plainText->SetContent("content1");
305 data.AddRecord(plainText);
306 auto ret = UdmfClient::GetInstance().PushDelayData(udKey, data);
307 EXPECT_EQ(ret, E_OK);
308 };
309 DataLoadParams dataLoadParams = {
310 .dataLoadInfo = dataLoadInfo1,
311 .loadHandler = loadHandler
312 };
313 std::string key = "";
314 auto status = UdmfClient::GetInstance().SetDelayInfo(dataLoadParams, key);
315 EXPECT_EQ(status, E_OK);
316
317 QueryOption option{
318 .intention = UD_INTENTION_DRAG,
319 .key = key
320 };
321 Summary summary;
322 status = UdmfClient::GetInstance().GetSummary(option, summary);
323 EXPECT_EQ(status, E_OK);
324 EXPECT_EQ(summary.totalSize, dataLoadInfo1.recordCount);
325 EXPECT_EQ(summary.summary.size(), dataLoadInfo1.types.size());
326 for (auto item: summary.summary) {
327 EXPECT_NE(summary.summary.find(item.first), summary.summary.end());
328 EXPECT_EQ(item.second, 0);
329 }
330
331 QueryOption query = {
332 .intention = UD_INTENTION_DRAG,
333 .key = key
334 };
335 AddPrivilege(query);
336
337 SetHapToken2();
__anon4bee1d940402(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 338 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
339 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d",
340 progress.progressStatus, progress.progress);
341 if (data == nullptr) {
342 ASSERT_TRUE(progress.progress != 0);
343 return;
344 }
345 ASSERT_EQ(1, data->GetRecords().size());
346 LOG_INFO(UDMF_TEST, "UdmfDelayDataTest002 callback end.");
347 };
348 GetDataParams params{
349 .query = query,
350 .progressIndicator = ProgressIndicator::DEFAULT,
351 .progressListener = callback,
352 .acceptableInfo = dataLoadInfo2,
353 };
354 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
355 EXPECT_EQ(status, E_OK);
356
357 LOG_INFO(UDMF_TEST, "UdmfDelayDataTest002 end.");
358 }
359
360 /* *
361 * @tc.name: UdmfDelayDataTest003
362 * @tc.desc: Test invalid parameters
363 * @tc.type: FUNC
364 */
365 HWTEST_F(UdmfDelayDataTest, UdmfDelayDataTest003, TestSize.Level1)
366 {
367 LOG_INFO(UDMF_TEST, "UdmfDelayDataTest003 begin.");
368
369 DataLoadInfo dataLoadInfo1{
370 .recordCount = 10,
371 .types{"general.plain-text", "general.html"},
372 };
373
374 SetHapToken1();
__anon4bee1d940502(const std::string &udKey, const DataLoadInfo &dataLoadInfo) 375 auto loadHandler = [] (const std::string &udKey, const DataLoadInfo &dataLoadInfo) {
376 LOG_INFO(UDMF_TEST, "loadHandler begin udKey=%{public}s.", udKey.c_str());
377 };
378 DataLoadParams dataLoadParams = {
379 .dataLoadInfo = dataLoadInfo1,
380 .loadHandler = loadHandler
381 };
382 std::string key = "";
383 auto status = UdmfClient::GetInstance().SetDelayInfo(dataLoadParams, key);
384 EXPECT_EQ(status, E_INVALID_PARAMETERS);
385 LOG_INFO(UDMF_TEST, "UdmfDelayDataTest003 end.");
386 }
387
388 /* *
389 * @tc.name: UdmfDelayDataTest004
390 * @tc.desc: Test invalid parameters
391 * @tc.type: FUNC
392 */
393 HWTEST_F(UdmfDelayDataTest, UdmfDelayDataTest004, TestSize.Level1)
394 {
395 LOG_INFO(UDMF_TEST, "UdmfDelayDataTest004 begin.");
396 SetHapToken1();
397 UnifiedData data;
398 auto obj = std::make_shared<Object>();
399 auto plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
400 plainText->SetContent("content1");
401 data.AddRecord(plainText);
402 std::string udKey = "";
403 auto ret = UdmfClient::GetInstance().PushDelayData(udKey, data);
404 EXPECT_EQ(ret, E_INVALID_PARAMETERS);
405 LOG_INFO(UDMF_TEST, "UdmfDelayDataTest004 end.");
406 }
407
SetDataInfoTest(const std::string & key)408 std::string UdmfDelayDataTest::SetDataInfoTest(const std::string &key)
409 {
410 DataLoadInfo dataLoadInfo1{
411 .recordCount = 10,
412 .types{"general.plain-text", "general.html"},
413 .sequenceKey = key
414 };
415 DataLoadInfo dataLoadInfo2{
416 .recordCount = 100,
417 .types{"general.plain-text"},
418 };
419 auto loadHandler = [dataLoadInfo2] (const std::string &udKey, const DataLoadInfo &dataLoadInfo) {
420 LOG_INFO(UDMF_TEST, "loadHandler begin udKey=%{public}s.", udKey.c_str());
421 EXPECT_EQ(dataLoadInfo.recordCount, dataLoadInfo2.recordCount);
422 EXPECT_EQ(dataLoadInfo.types, dataLoadInfo2.types);
423 UnifiedData data;
424 auto obj = std::make_shared<Object>();
425 auto plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
426 plainText->SetContent("content1");
427 data.AddRecord(plainText);
428 auto ret = UdmfClient::GetInstance().PushDelayData(udKey, data);
429 EXPECT_EQ(ret, E_OK);
430 };
431 DataLoadParams dataLoadParams = {
432 .dataLoadInfo = dataLoadInfo1,
433 .loadHandler = loadHandler
434 };
435 std::string udkey = "";
436 auto status = UdmfClient::GetInstance().SetDelayInfo(dataLoadParams, udkey);
437 EXPECT_EQ(status, E_OK);
438 return udkey;
439 }
440
GetDelayDataTest(const std::string & key)441 void UdmfDelayDataTest::GetDelayDataTest(const std::string &key)
442 {
443 DataLoadInfo dataLoadInfo2{
444 .recordCount = 100,
445 .types{"general.plain-text"},
446 };
447 auto callback = [](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
448 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d",
449 progress.progressStatus, progress.progress);
450 if (data == nullptr) {
451 ASSERT_TRUE(progress.progress != 0);
452 return;
453 }
454 ASSERT_EQ(1, data->GetRecords().size());
455 LOG_INFO(UDMF_TEST, "UdmfDelayDataTest002 callback end.");
456 };
457 QueryOption query = {
458 .intention = UD_INTENTION_DRAG,
459 .key = key
460 };
461 GetDataParams params{
462 .query = query,
463 .progressIndicator = ProgressIndicator::NONE,
464 .progressListener = callback,
465 .acceptableInfo = dataLoadInfo2,
466 };
467 auto status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
468 EXPECT_EQ(status, E_OK);
469 }
470
471 /* *
472 * @tc.name: UdmfDelayDataTest005
473 * @tc.desc: Test multi thread delay data
474 * @tc.type: FUNC
475 */
476 HWTEST_F(UdmfDelayDataTest, UdmfDelayDataTest005, TestSize.Level1)
477 {
478 LOG_INFO(UDMF_TEST, "UdmfDelayDataTest005 begin.");
479 SetHapToken1();
480 std::string key1 = UTILS::GenerateId();
481 std::string key2 = UTILS::GenerateId();
482 std::string key3 = UTILS::GenerateId();
483
__anon4bee1d940802() 484 std::thread t1([&]() {
485 key1 = SetDataInfoTest(key1);
486 GetDelayDataTest(key1);
487 });
__anon4bee1d940902() 488 std::thread t2([&]() {
489 key2 = SetDataInfoTest(key2);
490 GetDelayDataTest(key2);
491 });
__anon4bee1d940a02() 492 std::thread t3([&]() {
493 key3 = SetDataInfoTest(key3);
494 GetDelayDataTest(key3);
495 });
496 EXPECT_NO_FATAL_FAILURE(t1.join());
497 EXPECT_NO_FATAL_FAILURE(t2.join());
498 EXPECT_NO_FATAL_FAILURE(t3.join());
499
500 LOG_INFO(UDMF_TEST, "UdmfDelayDataTest005 end.");
501 }
502
503 /* *
504 * @tc.name: GetSequenceKey001
505 * @tc.desc: Test normal GetSequenceKey
506 * @tc.type: FUNC
507 */
508 HWTEST_F(UdmfDelayDataTest, GetSequenceKey001, TestSize.Level1)
509 {
510 LOG_INFO(UDMF_TEST, "UdmfDelayDataTest005 begin.");
511 EXPECT_EQ(UTILS::GetSequenceKey("abc/def"), "def");
512 EXPECT_EQ(UTILS::GetSequenceKey("one/two/three"), "three");
513 EXPECT_EQ(UTILS::GetSequenceKey("/abc/def/ghi"), "ghi");
514 LOG_INFO(UDMF_TEST, "GetSequenceKey001 end.");
515 }
516
517 /* *
518 * @tc.name: GetSequenceKey002
519 * @tc.desc: Test abnormal GetSequenceKey
520 * @tc.type: FUNC
521 */
522 HWTEST_F(UdmfDelayDataTest, GetSequenceKey002, TestSize.Level1)
523 {
524 LOG_INFO(UDMF_TEST, "GetSequenceKey002 begin.");
525 EXPECT_EQ(UTILS::GetSequenceKey("abc/"), "");
526 EXPECT_EQ(UTILS::GetSequenceKey("abcdef"), "");
527 EXPECT_EQ(UTILS::GetSequenceKey(""), "");
528 EXPECT_EQ(UTILS::GetSequenceKey("/"), "");
529 EXPECT_EQ(UTILS::GetSequenceKey("/abc/def/"), "");
530 LOG_INFO(UDMF_TEST, "GetSequenceKey002 end.");
531 }
532
NdkSetDataInfoTest()533 std::string UdmfDelayDataTest::NdkSetDataInfoTest()
534 {
535 DataLoadInfo dataLoadInfo1{
536 .recordCount = 10,
537 .types{"general.plain-text", "general.html"},
538 };
539 OH_UdmfDataLoadInfo *info1 = OH_UdmfDataLoadInfo_Create();
540 OH_UdmfDataLoadInfo_SetType(info1, "general.plain-text");
541 OH_UdmfDataLoadInfo_SetType(info1, "general.html");
542 OH_UdmfDataLoadInfo_SetRecordCount(info1, dataLoadInfo1.recordCount);
543
544 OH_Udmf_DataLoadHandler loadHandler = [] (OH_UdmfDataLoadInfo* acceptableInfo) {
545 LOG_INFO(UDMF_TEST, "loadHandler begin.");
546 auto recordCount = OH_UdmfDataLoadInfo_GetRecordCount(acceptableInfo);
547 EXPECT_EQ(recordCount, 100);
548 unsigned int typeCount = 0;
549 auto types = OH_UdmfDataLoadInfo_GetTypes(acceptableInfo, &typeCount);
550 EXPECT_EQ(typeCount, 1);
551 EXPECT_STREQ(types[0], "general.plain-text");
552
553 OH_UdmfData *unifiedData = OH_UdmfData_Create();
554 OH_UdmfRecord *record = OH_UdmfRecord_Create();
555 OH_UdsPlainText *plainText = OH_UdsPlainText_Create();
556 auto status = OH_UdsPlainText_SetContent(plainText, "content1");
557 EXPECT_EQ(status, E_OK);
558 status = OH_UdmfRecord_AddPlainText(record, plainText);
559 EXPECT_EQ(status, E_OK);
560 status = OH_UdmfData_AddRecord(unifiedData, record);
561 EXPECT_EQ(status, E_OK);
562 return unifiedData;
563 };
564
565 OH_UdmfDataLoadParams *ndkParams = OH_UdmfDataLoadParams_Create();
566 OH_UdmfDataLoadParams_SetDataLoadInfo(ndkParams, info1);
567 OH_UdmfDataLoadParams_SetLoadHandler(ndkParams, loadHandler);
568 DataLoadParams dataLoadParams;
569 auto status = DataParamsConversion::GetDataLoaderParams(*ndkParams, dataLoadParams);
570 EXPECT_EQ(status, E_OK);
571
572 SetHapToken1();
573 std::string udkey = "";
574 status = UdmfClient::GetInstance().SetDelayInfo(dataLoadParams, udkey);
575 EXPECT_EQ(status, E_OK);
576 return udkey;
577 }
578
NdkGetDelayDataTest(const std::string & key)579 void UdmfDelayDataTest::NdkGetDelayDataTest(const std::string &key)
580 {
581 DataLoadInfo dataLoadInfo2{
582 .recordCount = 100,
583 .types{"general.plain-text"},
584 };
585 QueryOption query = {
586 .intention = UD_INTENTION_DRAG,
587 .key = key
588 };
589 AddPrivilege(query);
590
591 SetHapToken2();
592 OH_UdmfDataLoadInfo *info2 = OH_UdmfDataLoadInfo_Create();
593 OH_UdmfDataLoadInfo_SetType(info2, "general.plain-text");
594 OH_UdmfDataLoadInfo_SetRecordCount(info2, dataLoadInfo2.recordCount);
595
596 OH_UdmfGetDataParams *param = OH_UdmfGetDataParams_Create();
597 OH_UdmfGetDataParams_SetProgressIndicator(param, Udmf_ProgressIndicator::UDMF_DEFAULT);
598 OH_UdmfGetDataParams_SetAcceptableInfo(param, info2);
599 OH_Udmf_DataProgressListener dataProgressListener = [](OH_Udmf_ProgressInfo *progressInfo, OH_UdmfData *data) {
600 auto progress = OH_UdmfProgressInfo_GetProgress(progressInfo);
601 auto status = OH_UdmfProgressInfo_GetStatus(progressInfo);
602 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d.", status, progress);
603 if (data == nullptr) {
604 ASSERT_TRUE(progress != 0);
605 return;
606 }
607 unsigned int count = 0;
608 OH_UdmfData_GetRecords(data, &count);
609 ASSERT_EQ(1, count);
610 LOG_INFO(UDMF_TEST, "UdmfDelayDataNDKTest001 callback end.");
611 };
612 OH_UdmfGetDataParams_SetDataProgressListener(param, dataProgressListener);
613 GetDataParams dataParams;
614 auto status = DataParamsConversion::GetInnerDataParams(*param, query, dataParams);
615 EXPECT_EQ(status, E_OK);
616 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(dataParams);
617 EXPECT_EQ(status, E_OK);
618 }
619
620 /* *
621 * @tc.name: UdmfDelayDataNDKTest001
622 * @tc.desc: Test CAPI delay data
623 * @tc.type: FUNC
624 */
625 HWTEST_F(UdmfDelayDataTest, UdmfDelayDataNDKTest001, TestSize.Level1)
626 {
627 LOG_INFO(UDMF_TEST, "UdmfDelayDataNDKTest001 begin.");
628 DataLoadInfo dataLoadInfo1{
629 .recordCount = 10,
630 .types{"general.plain-text", "general.html"},
631 };
632 DataLoadInfo dataLoadInfo2{
633 .recordCount = 100,
634 .types{"general.plain-text"},
635 };
636 auto key = NdkSetDataInfoTest();
637
638 QueryOption option{
639 .intention = UD_INTENTION_DRAG,
640 .key = key
641 };
642 Summary summary;
643 auto status = UdmfClient::GetInstance().GetSummary(option, summary);
644 EXPECT_EQ(status, E_OK);
645 EXPECT_EQ(summary.totalSize, dataLoadInfo1.recordCount);
646 EXPECT_EQ(summary.summary.size(), dataLoadInfo1.types.size());
647 for (auto item: summary.summary) {
648 EXPECT_NE(summary.summary.find(item.first), summary.summary.end());
649 EXPECT_EQ(item.second, 0);
650 }
651 NdkGetDelayDataTest(key);
652
653 LOG_INFO(UDMF_TEST, "UdmfDelayDataNDKTest001 end.");
654 }
655
656 /**
657 * @tc.name: OH_UdmfDataLoadParams_Create_Destroy_001
658 * @tc.desc: Test create and destroy of OH_UdmfDataLoadParams
659 * @tc.type: FUNC
660 */
661 HWTEST_F(UdmfDelayDataTest, OH_UdmfDataLoadParams_Create_Destroy_001, TestSize.Level0)
662 {
663 OH_UdmfDataLoadParams* params = OH_UdmfDataLoadParams_Create();
664 EXPECT_NE(params, nullptr);
665 OH_UdmfDataLoadParams_Destroy(params);
666 OH_UdmfDataLoadParams* paramsTest = nullptr;
667 OH_UdmfDataLoadParams_Destroy(paramsTest);
668 }
669
670 /**
671 * @tc.name: OH_UdmfDataLoadInfo_Create_Destroy_001
672 * @tc.desc: Test create and destroy of OH_UdmfDataLoadInfo
673 * @tc.type: FUNC
674 */
675 HWTEST_F(UdmfDelayDataTest, OH_UdmfDataLoadInfo_Create_Destroy_001, TestSize.Level0)
676 {
677 OH_UdmfDataLoadInfo* info = OH_UdmfDataLoadInfo_Create();
678 EXPECT_NE(info, nullptr);
679 OH_UdmfDataLoadInfo_Destroy(info);
680 }
681
682 /**
683 * @tc.name: OH_UdmfDataLoadInfo_GetTypes_Invalid_001
684 * @tc.desc: GetTypes with null dataLoadInfo or count
685 * @tc.type: FUNC
686 */
687 HWTEST_F(UdmfDelayDataTest, OH_UdmfDataLoadInfo_GetTypes_Invalid_001, TestSize.Level0)
688 {
689 unsigned int count = 0;
690 char** result1 = OH_UdmfDataLoadInfo_GetTypes(nullptr, &count);
691 EXPECT_EQ(result1, nullptr);
692
693 OH_UdmfDataLoadInfo* info = OH_UdmfDataLoadInfo_Create();
694 char** result2 = OH_UdmfDataLoadInfo_GetTypes(info, nullptr);
695 EXPECT_EQ(result2, nullptr);
696 OH_UdmfDataLoadInfo_Destroy(info);
697 }
698
699 /**
700 * @tc.name: OH_UdmfDataLoadInfo_SetType_And_GetTypes_001
701 * @tc.desc: Test SetType and GetTypes logic
702 * @tc.type: FUNC
703 */
704 HWTEST_F(UdmfDelayDataTest, OH_UdmfDataLoadInfo_SetType_And_GetTypes_001, TestSize.Level0)
705 {
706 OH_UdmfDataLoadInfo* info = OH_UdmfDataLoadInfo_Create();
707 EXPECT_NE(info, nullptr);
708
709 OH_UdmfDataLoadInfo_SetType(info, "image");
710 OH_UdmfDataLoadInfo_SetType(info, "text");
711 OH_UdmfDataLoadInfo_SetType(info, "text"); // duplicate
712
713 unsigned int count = 0;
714 OH_UdmfDataLoadInfo_GetTypes(info, &count);
715 EXPECT_EQ(count, 2);
716
717 OH_UdmfDataLoadInfo_Destroy(info);
718 }
719
720 /**
721 * @tc.name: OH_UdmfDataLoadInfo_SetRecordCount_GetRecordCount_001
722 * @tc.desc: Test setting and getting record count
723 * @tc.type: FUNC
724 */
725 HWTEST_F(UdmfDelayDataTest, OH_UdmfDataLoadInfo_SetRecordCount_GetRecordCount_001, TestSize.Level0)
726 {
727 OH_UdmfDataLoadInfo* info = OH_UdmfDataLoadInfo_Create();
728 EXPECT_NE(info, nullptr);
729
730 OH_UdmfDataLoadInfo_SetRecordCount(info, 10);
731 int count = OH_UdmfDataLoadInfo_GetRecordCount(info);
732 EXPECT_EQ(count, 10);
733
734 OH_UdmfDataLoadInfo_Destroy(info);
735 }
736 } // OHOS::Test