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 "UdmfAsyncClientTest"
16 #include <gtest/gtest.h>
17
18 #include "token_setproc.h"
19 #include "accesstoken_kit.h"
20 #include "nativetoken_kit.h"
21
22 #include "image.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 "async_task_params.h"
29 #include "data_params_conversion.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 = 2;
38 class UdmfAsyncClientTest : public testing::Test {
39 public:
40 Status SetDataTest(std::string key, ProgressIndicator progressIndicator);
41
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 void SetUp() override;
45 void TearDown() override;
46
47 static void AllocHapToken();
48 };
49
SetUpTestCase()50 void UdmfAsyncClientTest::SetUpTestCase()
51 {
52 AllocHapToken();
53 }
54
TearDownTestCase()55 void UdmfAsyncClientTest::TearDownTestCase()
56 {
57 std::this_thread::sleep_for(std::chrono::seconds(END_INTERVAL));
58 std::vector<UnifiedData> unifiedDataSet;
59 QueryOption query = {
60 .intention = UDMF::UD_INTENTION_DATA_HUB
61 };
62 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
63 EXPECT_EQ(E_OK, status);
64 auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.asyncdemo", 0);
65 AccessTokenKit::DeleteToken(tokenId);
66 }
67
SetUp()68 void UdmfAsyncClientTest::SetUp() {}
69
TearDown()70 void UdmfAsyncClientTest::TearDown() {}
71
72
AllocHapToken()73 void UdmfAsyncClientTest::AllocHapToken()
74 {
75 HapInfoParams info = {
76 .userID = USER_ID,
77 .bundleName = "ohos.test.asyncdemo",
78 .instIndex = 0,
79 .isSystemApp = false,
80 .appIDDesc = "ohos.test.asyncdemo"
81 };
82 HapPolicyParams policy = {
83 .apl = APL_SYSTEM_BASIC,
84 .domain = "test.domain",
85 .permList = {
86 {
87 .permissionName = "ohos.permission.MANAGE_UDMF_APP_SHARE_OPTION",
88 .bundleName = "ohos.test.asyncdemo",
89 .grantMode = 1,
90 .availableLevel = APL_SYSTEM_BASIC,
91 .label = "label",
92 .labelId = 1,
93 .description = "test2",
94 .descriptionId = 1
95 }
96 },
97 .permStateList = {
98 {
99 .permissionName = "ohos.permission.MANAGE_UDMF_APP_SHARE_OPTION",
100 .isGeneral = true,
101 .resDeviceID = { "local" },
102 .grantStatus = { PermissionState::PERMISSION_GRANTED },
103 .grantFlags = { 1 }
104 }
105 }
106 };
107 auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
108 SetSelfTokenID(tokenID.tokenIDEx);
109 }
110
111 /* *
112 * @tc.name: StartAsyncDataRetrieval001
113 * @tc.desc: Test get data success.
114 * @tc.type: FUNC
115 */
116 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval001, TestSize.Level1)
117 {
118 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval001 begin.");
119
120 CustomOption customOption = {
121 .intention = UDMF::UD_INTENTION_DRAG
122 };
123 UnifiedData data;
124 auto obj = std::make_shared<Object>();
125 auto plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
126 plainText->SetContent("content1");
127 data.AddRecord(plainText);
128 std::string key;
129 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
130 ASSERT_EQ(E_OK, status);
131
132 GetDataParams params;
133 QueryOption query = {
134 .intention = UD_INTENTION_DRAG,
135 .key = key
136 };
__anonaad499a60102(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 137 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
138 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
139 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
140 if (data == nullptr) {
141 ASSERT_TRUE(progress.progress != 0);
142 return;
143 }
144 ASSERT_EQ(1, data->GetRecords().size());
145 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval001 callback end.");
146 };
147 params.query = query;
148 params.progressIndicator = ProgressIndicator::NONE;
149 params.progressListener = callback;
150 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
151 ASSERT_EQ(E_OK, status);
152 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval001 end.");
153 }
154
155 /* *
156 * @tc.name: StartAsyncDataRetrieval002
157 * @tc.desc: Test CAPI get data success.
158 * @tc.type: FUNC
159 */
160 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval002, TestSize.Level1)
161 {
162 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval002 begin.");
163
164 CustomOption customOption = {
165 .intention = UDMF::UD_INTENTION_DRAG
166 };
167 UnifiedData data;
168 auto obj = std::make_shared<Object>();
169 auto plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
170 plainText->SetContent("content1");
171 data.AddRecord(plainText);
172 std::string key;
173 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
174 ASSERT_EQ(E_OK, status);
175
176 OH_UdmfGetDataParams param;
177 OH_UdmfGetDataParams_SetProgressIndicator(¶m, Udmf_ProgressIndicator::UDMF_DEFAULT);
178 OH_UdmfGetDataParams_SetDestUri(¶m, "/test/demo");
179 OH_UdmfGetDataParams_SetFileConflictOptions(¶m, Udmf_FileConflictOptions::UDMF_SKIP);
__anonaad499a60202(OH_Udmf_ProgressInfo *progressInfo, OH_UdmfData *data) 180 OH_Udmf_DataProgressListener dataProgressListener = [](OH_Udmf_ProgressInfo *progressInfo, OH_UdmfData *data) {
181 auto progress = OH_UdmfProgressInfo_GetProgress(progressInfo);
182 auto status = OH_UdmfProgressInfo_GetStatus(progressInfo);
183 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d.", status, progress);
184 if (data == nullptr) {
185 ASSERT_TRUE(progress != 0);
186 return;
187 }
188 unsigned int count = 0;
189 OH_UdmfData_GetRecords(data, &count);
190 ASSERT_EQ(1, count);
191 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval002 callback end.");
192 };
193 OH_UdmfGetDataParams_SetDataProgressListener(¶m, dataProgressListener);
194 QueryOption query = {
195 .intention = UD_INTENTION_DRAG,
196 .key = key
197 };
198 GetDataParams dataParams;
199 status = DataParamsConversion::GetInnerDataParams(param, query, dataParams);
200 ASSERT_EQ(E_OK, status);
201 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(dataParams);
202 ASSERT_EQ(E_OK, status);
203 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval002 end.");
204 }
205
206 /* *
207 * @tc.name: StartAsyncDataRetrieval003
208 * @tc.desc: Test get cache data success.
209 * @tc.type: FUNC
210 */
211 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval003, TestSize.Level1)
212 {
213 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval003 begin.");
214 auto status = UdmfClient::GetInstance().SetAppShareOption("drag", ShareOptions::IN_APP);
215 ASSERT_EQ(E_OK, status);
216
217 CustomOption customOption = {
218 .intention = UDMF::UD_INTENTION_DRAG
219 };
220 UnifiedData data;
221 auto obj = std::make_shared<Object>();
222 auto plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
223 plainText->SetContent("content1");
224 data.AddRecord(plainText);
225 std::string key;
226 status = UdmfClient::GetInstance().SetData(customOption, data, key);
227 ASSERT_EQ(E_OK, status);
228
229 GetDataParams params;
230 QueryOption query = {
231 .intention = UD_INTENTION_DRAG,
232 .key = key
233 };
__anonaad499a60302(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 234 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
235 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
236 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
237 if (data == nullptr) {
238 ASSERT_TRUE(progress.progress != 0);
239 return;
240 }
241 ASSERT_EQ(1, data->GetRecords().size());
242 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval003 callback end.");
243 };
244 params.query = query;
245 params.progressIndicator = ProgressIndicator::DEFAULT;
246 params.progressListener = callback;
247 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
248 ASSERT_EQ(E_OK, status);
249
250 status = UdmfClient::GetInstance().RemoveAppShareOption("drag");
251 ASSERT_EQ(E_OK, status);
252 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval003 end.");
253 }
254
255 /* *
256 * @tc.name: StartAsyncDataRetrieval004
257 * @tc.desc: Test get data cost 1s.
258 * @tc.type: FUNC
259 */
260 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval004, TestSize.Level1)
261 {
262 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval004 begin.");
263
264 CustomOption customOption = {
265 .intention = UDMF::UD_INTENTION_DRAG
266 };
267 UnifiedData data;
268 auto obj = std::make_shared<Object>();
269 auto plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
270 plainText->SetContent("content1");
271 data.AddRecord(plainText);
272 std::string key;
273 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
274 ASSERT_EQ(E_OK, status);
275
276 GetDataParams params;
277 QueryOption query = {
278 .intention = UD_INTENTION_DRAG,
279 .key = key
280 };
__anonaad499a60402(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 281 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
282 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
283 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
284 if (data == nullptr) {
285 ASSERT_TRUE(progress.progress != 0);
286 return;
287 }
288 ASSERT_EQ(1, data->GetRecords().size());
289 std::this_thread::sleep_for(std::chrono::milliseconds(500));
290 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval003 callback end.");
291 };
292 params.query = query;
293 params.progressIndicator = ProgressIndicator::NONE;
294 params.progressListener = callback;
295 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
296 std::this_thread::sleep_for(std::chrono::milliseconds(500));
297 ASSERT_EQ(E_OK, status);
298
299 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval004 end.");
300 }
301
302 /* *
303 * @tc.name: StartAsyncDataRetrieval005
304 * @tc.desc: Test get no data.
305 * @tc.type: FUNC
306 */
307 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval005, TestSize.Level1)
308 {
309 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval005 begin.");
310
311 GetDataParams params;
312 QueryOption query = {
313 .intention = UD_INTENTION_DRAG,
314 .key = "udmf://drag/com.demo/NotFoundData"
315 };
__anonaad499a60502(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 316 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
317 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
318 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
319 if (progress.progressStatus == 4) {
320 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval005 demo1 callback end.");
321 return;
322 }
323 };
324 params.query = query;
325 params.progressIndicator = ProgressIndicator::NONE;
326 params.progressListener = callback;
327 auto status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
328 ASSERT_EQ(E_OK, status);
329 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval005 end.");
330 }
331
332 /* *
333 * @tc.name: StartAsyncDataRetrieval006
334 * @tc.desc: Test invalid key.
335 * @tc.type: FUNC
336 */
337 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval006, TestSize.Level1)
338 {
339 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval006 begin.");
340
341 GetDataParams params;
342 QueryOption query = {
343 .intention = UD_INTENTION_DRAG,
344 .key = "InvalidKey"
345 };
__anonaad499a60602(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 346 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
347 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
348 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
349 if (progress.progressStatus == 3) {
350 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval006 demo2 callback end.");
351 return;
352 }
353 };
354 params.query = query;
355 params.progressIndicator = ProgressIndicator::DEFAULT;
356 params.progressListener = callback;
357 auto status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
358 ASSERT_EQ(E_OK, status);
359 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval006 end.");
360 }
361
SetDataTest(std::string key,ProgressIndicator progressIndicator)362 Status UdmfAsyncClientTest::SetDataTest(std::string key, ProgressIndicator progressIndicator)
363 {
364 GetDataParams params;
365 QueryOption query = {
366 .intention = UD_INTENTION_DRAG,
367 .key = key
368 };
369 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
370 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
371 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
372 if (data == nullptr) {
373 ASSERT_TRUE(progress.progress != 0);
374 return;
375 }
376 };
377 params.query = query;
378 params.progressIndicator = progressIndicator;
379 params.progressListener = callback;
380 return UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
381 }
382
383 /* *
384 * @tc.name: StartAsyncDataRetrieval007
385 * @tc.desc: Test multithreading different key.
386 * @tc.type: FUNC
387 */
388 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval007, TestSize.Level1)
389 {
390 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval007 begin.");
391
392 CustomOption customOption = {
393 .intention = UDMF::UD_INTENTION_DRAG
394 };
395 UnifiedData data;
396 auto obj = std::make_shared<Object>();
397 auto plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
398 plainText->SetContent("content1");
399 data.AddRecord(plainText);
400 std::string key1;
401 auto status = UdmfClient::GetInstance().SetData(customOption, data, key1);
402 ASSERT_EQ(E_OK, status);
403
404 std::string key2;
405 customOption = {
406 .intention = UDMF::UD_INTENTION_DRAG
407 };
408 plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
409 plainText->SetContent("content1");
410 data.AddRecord(plainText);
411 status = UdmfClient::GetInstance().SetData(customOption, data, key2);
412 ASSERT_EQ(E_OK, status);
413
414 std::string key3;
415 customOption = {
416 .intention = UDMF::UD_INTENTION_DRAG
417 };
418 plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
419 plainText->SetContent("content1");
420 data.AddRecord(plainText);
421 status = UdmfClient::GetInstance().SetData(customOption, data, key3);
422 ASSERT_EQ(E_OK, status);
423
__anonaad499a60802() 424 std::thread t1([&]() {
425 auto status = SetDataTest(key1, ProgressIndicator::DEFAULT);
426 ASSERT_EQ(E_OK, status);
427 });
428 EXPECT_NO_FATAL_FAILURE(t1.join());
__anonaad499a60902() 429 std::thread t2([&]() {
430 auto status = SetDataTest(key2, ProgressIndicator::NONE);
431 ASSERT_EQ(E_OK, status);
432 });
433 EXPECT_NO_FATAL_FAILURE(t2.join());
__anonaad499a60a02() 434 std::thread t3([&]() {
435 auto status = SetDataTest(key3, ProgressIndicator::DEFAULT);
436 ASSERT_EQ(E_OK, status);
437 });
438 EXPECT_NO_FATAL_FAILURE(t3.join());
439 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval007 end.");
440 }
441
442 /* *
443 * @tc.name: StartAsyncDataRetrieval008
444 * @tc.desc: Test multithreading same key.
445 * @tc.type: FUNC
446 */
447 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval008, TestSize.Level1)
448 {
449 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval008 begin.");
450
451 CustomOption customOption = {
452 .intention = UDMF::UD_INTENTION_DRAG
453 };
454 UnifiedData data;
455 auto obj = std::make_shared<Object>();
456 auto plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
457 plainText->SetContent("content1");
458 data.AddRecord(plainText);
459 std::string key1;
460 auto status = UdmfClient::GetInstance().SetData(customOption, data, key1);
461 ASSERT_EQ(E_OK, status);
462
__anonaad499a60b02() 463 std::thread t1([&]() {
464 auto status = SetDataTest(key1, ProgressIndicator::DEFAULT);
465 std::this_thread::sleep_for(std::chrono::milliseconds(10));
466 ASSERT_EQ(E_OK, status);
467 });
468 EXPECT_NO_FATAL_FAILURE(t1.join());
__anonaad499a60c02() 469 std::thread t2([&]() {
470 std::this_thread::sleep_for(std::chrono::milliseconds(10));
471 auto status = SetDataTest(key1, ProgressIndicator::NONE);
472 ASSERT_EQ(E_IDEMPOTENT_ERROR, status);
473 });
474 EXPECT_NO_FATAL_FAILURE(t2.join());
__anonaad499a60d02() 475 std::thread t3([&]() {
476 std::this_thread::sleep_for(std::chrono::milliseconds(10));
477 auto status = SetDataTest(key1, ProgressIndicator::DEFAULT);
478 ASSERT_EQ(E_IDEMPOTENT_ERROR, status);
479 });
480 EXPECT_NO_FATAL_FAILURE(t3.join());
481 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval008 end.");
482 }
483
484 /* *
485 * @tc.name: StartAsyncDataRetrieval009
486 * @tc.desc: Test Get File type.
487 * @tc.type: FUNC
488 */
489 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval009, TestSize.Level1)
490 {
491 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval009 begin.");
492
493 CustomOption customOption = {
494 .intention = UDMF::UD_INTENTION_DRAG
495 };
496 UnifiedData data;
497 auto obj = std::make_shared<Object>();
498 auto file = std::make_shared<Image>(UDType::IMAGE, obj);
499 file->SetUri("uri");
500 file->SetRemoteUri("remoteUri");
501 data.AddRecord(file);
502 std::string key;
503 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
504 ASSERT_EQ(E_OK, status);
505
506 GetDataParams params;
507 QueryOption query = {
508 .intention = UD_INTENTION_DRAG,
509 .key = key
510 };
__anonaad499a60e02(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 511 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
512 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
513 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
514 if (data == nullptr) {
515 ASSERT_TRUE(progress.progress != 0);
516 return;
517 }
518 ASSERT_EQ(1, data->GetRecords().size());
519 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval009 callback end.");
520 };
521 params.query = query;
522 params.progressIndicator = ProgressIndicator::DEFAULT;
523 params.progressListener = callback;
524 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
525 ASSERT_EQ(E_OK, status);
526 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval009 end.");
527 }
528
529 /* *
530 * @tc.name: StartAsyncDataRetrieval010
531 * @tc.desc: Test Invalid params.
532 * @tc.type: FUNC
533 */
534 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval010, TestSize.Level1)
535 {
536 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval010 begin.");
537
538 GetDataParams params;
539 QueryOption query = {
540 .intention = UDMF::UD_INTENTION_DRAG
541 };
542 params.query = query;
543 params.progressIndicator = ProgressIndicator::DEFAULT;
__anonaad499a60f02(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 544 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {};
545 params.progressListener = callback;
546 auto status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
547 ASSERT_EQ(E_INVALID_PARAMETERS, status);
548
549 query = {
550 .intention = UDMF::UD_INTENTION_DATA_HUB,
551 .key = "udmf://a/b/c"
552 };
553 params.query = query;
554 params.progressIndicator = ProgressIndicator::DEFAULT;
555 params.progressListener = callback;
556 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
557 ASSERT_EQ(E_INVALID_PARAMETERS, status);
558
559 query = {
560 .intention = UDMF::UD_INTENTION_DRAG,
561 .key = "udmf://a/b/c"
562 };
563 params.query = query;
564 params.progressIndicator = ProgressIndicator::DEFAULT;
565 params.progressListener = nullptr;
566 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
567 ASSERT_EQ(E_INVALID_PARAMETERS, status);
568 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval010 end.");
569 }
570 } // OHOS::Test