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 "udmf_executor.h"
29 #include "async_task_params.h"
30 #include "data_params_conversion.h"
31
32 using namespace testing::ext;
33 using namespace OHOS::Security::AccessToken;
34 using namespace OHOS::UDMF;
35 using namespace OHOS;
36 namespace OHOS::Test {
37 static constexpr int USER_ID = 100;
38 static constexpr int END_INTERVAL = 2;
39 class UdmfAsyncClientTest : public testing::Test {
40 public:
41 Status SetDataTest(std::string key, ProgressIndicator progressIndicator);
42
43 static void SetUpTestCase();
44 static void TearDownTestCase();
45 void SetUp() override;
46 void TearDown() override;
47
48 static void AllocHapToken();
49 };
50
SetUpTestCase()51 void UdmfAsyncClientTest::SetUpTestCase()
52 {
53 AllocHapToken();
54 }
55
TearDownTestCase()56 void UdmfAsyncClientTest::TearDownTestCase()
57 {
58 std::this_thread::sleep_for(std::chrono::seconds(END_INTERVAL));
59 std::vector<UnifiedData> unifiedDataSet;
60 QueryOption query = {
61 .intention = UDMF::UD_INTENTION_DATA_HUB
62 };
63 auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
64 EXPECT_EQ(E_OK, status);
65 auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.asyncdemo", 0);
66 AccessTokenKit::DeleteToken(tokenId);
67 }
68
SetUp()69 void UdmfAsyncClientTest::SetUp() {}
70
TearDown()71 void UdmfAsyncClientTest::TearDown() {}
72
73
AllocHapToken()74 void UdmfAsyncClientTest::AllocHapToken()
75 {
76 HapInfoParams info = {
77 .userID = USER_ID,
78 .bundleName = "ohos.test.asyncdemo",
79 .instIndex = 0,
80 .isSystemApp = false,
81 .appIDDesc = "ohos.test.asyncdemo"
82 };
83 HapPolicyParams policy = {
84 .apl = APL_SYSTEM_BASIC,
85 .domain = "test.domain",
86 .permList = {
87 {
88 .permissionName = "ohos.permission.MANAGE_UDMF_APP_SHARE_OPTION",
89 .bundleName = "ohos.test.asyncdemo",
90 .grantMode = 1,
91 .availableLevel = APL_SYSTEM_BASIC,
92 .label = "label",
93 .labelId = 1,
94 .description = "test2",
95 .descriptionId = 1
96 }
97 },
98 .permStateList = {
99 {
100 .permissionName = "ohos.permission.MANAGE_UDMF_APP_SHARE_OPTION",
101 .isGeneral = true,
102 .resDeviceID = { "local" },
103 .grantStatus = { PermissionState::PERMISSION_GRANTED },
104 .grantFlags = { 1 }
105 }
106 }
107 };
108 auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
109 SetSelfTokenID(tokenID.tokenIDEx);
110 }
111
112 /* *
113 * @tc.name: StartAsyncDataRetrieval001
114 * @tc.desc: Test get data success.
115 * @tc.type: FUNC
116 */
117 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval001, TestSize.Level1)
118 {
119 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval001 begin.");
120
121 CustomOption customOption = {
122 .intention = UDMF::UD_INTENTION_DRAG
123 };
124 UnifiedData data;
125 auto obj = std::make_shared<Object>();
126 auto plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
127 plainText->SetContent("content1");
128 data.AddRecord(plainText);
129 std::string key;
130 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
131 ASSERT_EQ(E_OK, status);
132
133 GetDataParams params;
134 QueryOption query = {
135 .intention = UD_INTENTION_DRAG,
136 .key = key
137 };
__anon0eb97f480102(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 138 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
139 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
140 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
141 if (data == nullptr) {
142 ASSERT_TRUE(progress.progress != 0);
143 return;
144 }
145 ASSERT_EQ(1, data->GetRecords().size());
146 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval001 callback end.");
147 };
148 params.query = query;
149 params.progressIndicator = ProgressIndicator::NONE;
150 params.progressListener = callback;
151 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
152 ASSERT_EQ(E_OK, status);
153 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval001 end.");
154 }
155
156 /* *
157 * @tc.name: StartAsyncDataRetrieval002
158 * @tc.desc: Test CAPI get data success.
159 * @tc.type: FUNC
160 */
161 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval002, TestSize.Level1)
162 {
163 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval002 begin.");
164
165 CustomOption customOption = {
166 .intention = UDMF::UD_INTENTION_DRAG
167 };
168 UnifiedData data;
169 auto obj = std::make_shared<Object>();
170 auto plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
171 plainText->SetContent("content1");
172 data.AddRecord(plainText);
173 std::string key;
174 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
175 ASSERT_EQ(E_OK, status);
176
177 OH_UdmfGetDataParams param;
178 OH_UdmfGetDataParams_SetProgressIndicator(¶m, Udmf_ProgressIndicator::UDMF_DEFAULT);
179 OH_UdmfGetDataParams_SetDestUri(¶m, "/test/demo");
180 OH_UdmfGetDataParams_SetFileConflictOptions(¶m, Udmf_FileConflictOptions::UDMF_SKIP);
__anon0eb97f480202(OH_Udmf_ProgressInfo *progressInfo, OH_UdmfData *data) 181 OH_Udmf_DataProgressListener dataProgressListener = [](OH_Udmf_ProgressInfo *progressInfo, OH_UdmfData *data) {
182 auto progress = OH_UdmfProgressInfo_GetProgress(progressInfo);
183 auto status = OH_UdmfProgressInfo_GetStatus(progressInfo);
184 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d.", status, progress);
185 if (data == nullptr) {
186 ASSERT_TRUE(progress != 0);
187 return;
188 }
189 unsigned int count = 0;
190 OH_UdmfData_GetRecords(data, &count);
191 ASSERT_EQ(1, count);
192 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval002 callback end.");
193 };
194 OH_UdmfGetDataParams_SetDataProgressListener(¶m, dataProgressListener);
195 QueryOption query = {
196 .intention = UD_INTENTION_DRAG,
197 .key = key
198 };
199 GetDataParams dataParams;
200 status = DataParamsConversion::GetInnerDataParams(param, query, dataParams);
201 ASSERT_EQ(E_OK, status);
202 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(dataParams);
203 ASSERT_EQ(E_OK, status);
204 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval002 end.");
205 }
206
207 /* *
208 * @tc.name: StartAsyncDataRetrieval003
209 * @tc.desc: Test get cache data success.
210 * @tc.type: FUNC
211 */
212 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval003, TestSize.Level1)
213 {
214 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval003 begin.");
215 auto status = UdmfClient::GetInstance().SetAppShareOption("drag", ShareOptions::IN_APP);
216 ASSERT_EQ(E_OK, status);
217
218 CustomOption customOption = {
219 .intention = UDMF::UD_INTENTION_DRAG
220 };
221 UnifiedData data;
222 auto obj = std::make_shared<Object>();
223 auto plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
224 plainText->SetContent("content1");
225 data.AddRecord(plainText);
226 std::string key;
227 status = UdmfClient::GetInstance().SetData(customOption, data, key);
228 ASSERT_EQ(E_OK, status);
229
230 GetDataParams params;
231 QueryOption query = {
232 .intention = UD_INTENTION_DRAG,
233 .key = key
234 };
__anon0eb97f480302(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 235 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
236 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
237 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
238 if (data == nullptr) {
239 ASSERT_TRUE(progress.progress != 0);
240 return;
241 }
242 ASSERT_EQ(1, data->GetRecords().size());
243 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval003 callback end.");
244 };
245 params.query = query;
246 params.progressIndicator = ProgressIndicator::DEFAULT;
247 params.progressListener = callback;
248 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
249 ASSERT_EQ(E_OK, status);
250
251 status = UdmfClient::GetInstance().RemoveAppShareOption("drag");
252 ASSERT_EQ(E_OK, status);
253 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval003 end.");
254 }
255
256 /* *
257 * @tc.name: StartAsyncDataRetrieval004
258 * @tc.desc: Test get data cost 1s.
259 * @tc.type: FUNC
260 */
261 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval004, TestSize.Level1)
262 {
263 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval004 begin.");
264
265 CustomOption customOption = {
266 .intention = UDMF::UD_INTENTION_DRAG
267 };
268 UnifiedData data;
269 auto obj = std::make_shared<Object>();
270 auto plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
271 plainText->SetContent("content1");
272 data.AddRecord(plainText);
273 std::string key;
274 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
275 ASSERT_EQ(E_OK, status);
276
277 GetDataParams params;
278 QueryOption query = {
279 .intention = UD_INTENTION_DRAG,
280 .key = key
281 };
__anon0eb97f480402(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 282 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
283 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
284 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
285 if (data == nullptr) {
286 ASSERT_TRUE(progress.progress != 0);
287 return;
288 }
289 ASSERT_EQ(1, data->GetRecords().size());
290 std::this_thread::sleep_for(std::chrono::milliseconds(500));
291 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval003 callback end.");
292 };
293 params.query = query;
294 params.progressIndicator = ProgressIndicator::NONE;
295 params.progressListener = callback;
296 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
297 std::this_thread::sleep_for(std::chrono::milliseconds(500));
298 ASSERT_EQ(E_OK, status);
299
300 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval004 end.");
301 }
302
303 /* *
304 * @tc.name: StartAsyncDataRetrieval005
305 * @tc.desc: Test get no data.
306 * @tc.type: FUNC
307 */
308 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval005, TestSize.Level1)
309 {
310 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval005 begin.");
311
312 GetDataParams params;
313 QueryOption query = {
314 .intention = UD_INTENTION_DRAG,
315 .key = "udmf://drag/com.demo/NotFoundData"
316 };
__anon0eb97f480502(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 317 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
318 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
319 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
320 if (progress.progressStatus == 4) {
321 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval005 demo1 callback end.");
322 return;
323 }
324 };
325 params.query = query;
326 params.progressIndicator = ProgressIndicator::NONE;
327 params.progressListener = callback;
328 auto status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
329 ASSERT_EQ(E_OK, status);
330 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval005 end.");
331 }
332
333 /* *
334 * @tc.name: StartAsyncDataRetrieval006
335 * @tc.desc: Test invalid key.
336 * @tc.type: FUNC
337 */
338 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval006, TestSize.Level1)
339 {
340 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval006 begin.");
341
342 GetDataParams params;
343 QueryOption query = {
344 .intention = UD_INTENTION_DRAG,
345 .key = "InvalidKey"
346 };
__anon0eb97f480602(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 347 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
348 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
349 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
350 if (progress.progressStatus == 3) {
351 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval006 demo2 callback end.");
352 return;
353 }
354 };
355 params.query = query;
356 params.progressIndicator = ProgressIndicator::DEFAULT;
357 params.progressListener = callback;
358 auto status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
359 ASSERT_EQ(E_OK, status);
360 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval006 end.");
361 }
362
SetDataTest(std::string key,ProgressIndicator progressIndicator)363 Status UdmfAsyncClientTest::SetDataTest(std::string key, ProgressIndicator progressIndicator)
364 {
365 GetDataParams params;
366 QueryOption query = {
367 .intention = UD_INTENTION_DRAG,
368 .key = key
369 };
370 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
371 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
372 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
373 if (data == nullptr) {
374 ASSERT_TRUE(progress.progress != 0);
375 return;
376 }
377 };
378 params.query = query;
379 params.progressIndicator = progressIndicator;
380 params.progressListener = callback;
381 return UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
382 }
383
384 /* *
385 * @tc.name: StartAsyncDataRetrieval007
386 * @tc.desc: Test multithreading different key.
387 * @tc.type: FUNC
388 */
389 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval007, TestSize.Level1)
390 {
391 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval007 begin.");
392
393 CustomOption customOption = {
394 .intention = UDMF::UD_INTENTION_DRAG
395 };
396 UnifiedData data;
397 auto obj = std::make_shared<Object>();
398 auto plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
399 plainText->SetContent("content1");
400 data.AddRecord(plainText);
401 std::string key1;
402 auto status = UdmfClient::GetInstance().SetData(customOption, data, key1);
403 ASSERT_EQ(E_OK, status);
404
405 std::string key2;
406 customOption = {
407 .intention = UDMF::UD_INTENTION_DRAG
408 };
409 plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
410 plainText->SetContent("content1");
411 data.AddRecord(plainText);
412 status = UdmfClient::GetInstance().SetData(customOption, data, key2);
413 ASSERT_EQ(E_OK, status);
414
415 std::string key3;
416 customOption = {
417 .intention = UDMF::UD_INTENTION_DRAG
418 };
419 plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
420 plainText->SetContent("content1");
421 data.AddRecord(plainText);
422 status = UdmfClient::GetInstance().SetData(customOption, data, key3);
423 ASSERT_EQ(E_OK, status);
424
__anon0eb97f480802() 425 std::thread t1([&]() {
426 auto status = SetDataTest(key1, ProgressIndicator::DEFAULT);
427 ASSERT_EQ(E_OK, status);
428 });
429 EXPECT_NO_FATAL_FAILURE(t1.join());
__anon0eb97f480902() 430 std::thread t2([&]() {
431 auto status = SetDataTest(key2, ProgressIndicator::NONE);
432 ASSERT_EQ(E_OK, status);
433 });
434 EXPECT_NO_FATAL_FAILURE(t2.join());
__anon0eb97f480a02() 435 std::thread t3([&]() {
436 auto status = SetDataTest(key3, ProgressIndicator::DEFAULT);
437 ASSERT_EQ(E_OK, status);
438 });
439 EXPECT_NO_FATAL_FAILURE(t3.join());
440 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval007 end.");
441 }
442
443 /* *
444 * @tc.name: StartAsyncDataRetrieval008
445 * @tc.desc: Test multithreading same key.
446 * @tc.type: FUNC
447 */
448 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval008, TestSize.Level1)
449 {
450 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval008 begin.");
451
452 CustomOption customOption = {
453 .intention = UDMF::UD_INTENTION_DRAG
454 };
455 UnifiedData data;
456 auto obj = std::make_shared<Object>();
457 auto plainText = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
458 plainText->SetContent("content1");
459 data.AddRecord(plainText);
460 std::string key1;
461 auto status = UdmfClient::GetInstance().SetData(customOption, data, key1);
462 ASSERT_EQ(E_OK, status);
463
__anon0eb97f480b02() 464 std::thread t1([&]() {
465 auto status = SetDataTest(key1, ProgressIndicator::DEFAULT);
466 std::this_thread::sleep_for(std::chrono::milliseconds(10));
467 ASSERT_EQ(E_OK, status);
468 });
469 EXPECT_NO_FATAL_FAILURE(t1.join());
__anon0eb97f480c02() 470 std::thread t2([&]() {
471 std::this_thread::sleep_for(std::chrono::milliseconds(10));
472 auto status = SetDataTest(key1, ProgressIndicator::NONE);
473 ASSERT_EQ(E_IDEMPOTENT_ERROR, status);
474 });
475 EXPECT_NO_FATAL_FAILURE(t2.join());
__anon0eb97f480d02() 476 std::thread t3([&]() {
477 std::this_thread::sleep_for(std::chrono::milliseconds(10));
478 auto status = SetDataTest(key1, ProgressIndicator::DEFAULT);
479 ASSERT_EQ(E_IDEMPOTENT_ERROR, status);
480 });
481 EXPECT_NO_FATAL_FAILURE(t3.join());
482 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval008 end.");
483 }
484
485 /* *
486 * @tc.name: StartAsyncDataRetrieval009
487 * @tc.desc: Test Get File type.
488 * @tc.type: FUNC
489 */
490 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval009, TestSize.Level1)
491 {
492 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval009 begin.");
493
494 CustomOption customOption = {
495 .intention = UDMF::UD_INTENTION_DRAG
496 };
497 UnifiedData data;
498 auto obj = std::make_shared<Object>();
499 auto file = std::make_shared<Image>(UDType::IMAGE, obj);
500 file->SetUri("uri");
501 file->SetRemoteUri("remoteUri");
502 data.AddRecord(file);
503 std::string key;
504 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
505 ASSERT_EQ(E_OK, status);
506
507 GetDataParams params;
508 QueryOption query = {
509 .intention = UD_INTENTION_DRAG,
510 .key = key
511 };
__anon0eb97f480e02(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 512 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
513 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
514 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
515 if (data == nullptr) {
516 ASSERT_TRUE(progress.progress != 0);
517 return;
518 }
519 ASSERT_EQ(1, data->GetRecords().size());
520 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval009 callback end.");
521 };
522 params.query = query;
523 params.progressIndicator = ProgressIndicator::DEFAULT;
524 params.progressListener = callback;
525 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
526 ASSERT_EQ(E_OK, status);
527 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval009 end.");
528 }
529
530 /* *
531 * @tc.name: StartAsyncDataRetrieval010
532 * @tc.desc: Test Invalid params.
533 * @tc.type: FUNC
534 */
535 HWTEST_F(UdmfAsyncClientTest, StartAsyncDataRetrieval010, TestSize.Level1)
536 {
537 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval010 begin.");
538
539 GetDataParams params;
540 QueryOption query = {
541 .intention = UDMF::UD_INTENTION_DRAG
542 };
543 params.query = query;
544 params.progressIndicator = ProgressIndicator::DEFAULT;
__anon0eb97f480f02(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 545 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {};
546 params.progressListener = callback;
547 auto status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
548 ASSERT_EQ(E_INVALID_PARAMETERS, status);
549
550 query = {
551 .intention = UDMF::UD_INTENTION_DATA_HUB,
552 .key = "udmf://a/b/c"
553 };
554 params.query = query;
555 params.progressIndicator = ProgressIndicator::DEFAULT;
556 params.progressListener = callback;
557 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
558 ASSERT_EQ(E_INVALID_PARAMETERS, status);
559
560 query = {
561 .intention = UDMF::UD_INTENTION_DRAG,
562 .key = "udmf://a/b/c"
563 };
564 params.query = query;
565 params.progressIndicator = ProgressIndicator::DEFAULT;
566 params.progressListener = nullptr;
567 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
568 ASSERT_EQ(E_INVALID_PARAMETERS, status);
569 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval010 end.");
570 }
571
572 /**
573 * @tc.name: Cancel001
574 * @tc.desc: Test Normal Cancel
575 * @tc.type: FUNC
576 */
577 HWTEST_F(UdmfAsyncClientTest, Cancel001, TestSize.Level1)
578 {
579 LOG_INFO(UDMF_TEST, "Cancel001 begin.");
580 CustomOption customOption = {
581 .intention = UDMF::UD_INTENTION_DRAG
582 };
583 UnifiedData data;
584 auto obj = std::make_shared<Object>();
585 auto file = std::make_shared<Image>(UDType::IMAGE, obj);
586 file->SetUri("uri");
587 file->SetRemoteUri("remoteUri");
588 data.AddRecord(file);
589 std::string key;
590 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
591 ASSERT_EQ(E_OK, status);
592
593 GetDataParams params;
594 QueryOption query = {
595 .intention = UD_INTENTION_DRAG,
596 .key = key
597 };
__anon0eb97f481002(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 598 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
599 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
600 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
601 if (data == nullptr) {
602 ASSERT_TRUE(progress.progress != 0);
603 return;
604 }
605 ASSERT_EQ(1, data->GetRecords().size());
606 LOG_INFO(UDMF_TEST, "StartAsyncDataRetrieval009 callback end.");
607 };
608 params.query = query;
609 params.progressIndicator = ProgressIndicator::DEFAULT;
610 params.progressListener = callback;
611 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
612 ASSERT_EQ(E_OK, status);
613 std::string businessUdKey = "udmf://a/b/c";
614 status = UdmfAsyncClient::GetInstance().Cancel(params.query.key);
615 ASSERT_EQ(E_OK, status);
616
617 LOG_INFO(UDMF_TEST, "Cancel001 end.");
618 }
619
620 /**
621 * @tc.name: Cancel002
622 * @tc.desc: Test Invalid params.
623 * @tc.type: FUNC
624 */
625 HWTEST_F(UdmfAsyncClientTest, Cancel002, TestSize.Level1)
626 {
627 LOG_INFO(UDMF_TEST, "Cancel002 begin.");
628 CustomOption customOption = {
629 .intention = UDMF::UD_INTENTION_DRAG
630 };
631 UnifiedData data;
632 auto obj = std::make_shared<Object>();
633 auto file = std::make_shared<Image>(UDType::IMAGE, obj);
634 file->SetUri("uri");
635 file->SetRemoteUri("remoteUri");
636 data.AddRecord(file);
637 std::string key;
638 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
639 ASSERT_EQ(E_OK, status);
640
641 GetDataParams params;
642 QueryOption query = {
643 .intention = UD_INTENTION_DRAG,
644 .key = key
645 };
__anon0eb97f481102(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 646 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
647 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
648 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
649 if (data == nullptr) {
650 ASSERT_TRUE(progress.progress != 0);
651 return;
652 }
653 ASSERT_EQ(1, data->GetRecords().size());
654 LOG_INFO(UDMF_TEST, "Cancel002 callback end.");
655 };
656 params.query = query;
657 params.progressIndicator = ProgressIndicator::DEFAULT;
658 params.progressListener = callback;
659 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
660 ASSERT_EQ(E_OK, status);
661 std::string businessUdKey = "udmf";
662 status = UdmfAsyncClient::GetInstance().Cancel(businessUdKey);
663 ASSERT_EQ(E_ERROR, status);
664
665 LOG_INFO(UDMF_TEST, "Cancel002 end.");
666 }
667
668 /* *
669 * @tc.name: CancelOnSingleTask001
670 * @tc.desc: Test one data
671 * @tc.type: FUNC
672 */
673 HWTEST_F(UdmfAsyncClientTest, CancelOnSingleTask001, TestSize.Level1)
674 {
675 LOG_INFO(UDMF_TEST, "CancelOnSingleTask001 begin.");
676 CustomOption customOption = {
677 .intention = UDMF::UD_INTENTION_DRAG
678 };
679 UnifiedData data;
680 auto obj = std::make_shared<Object>();
681 auto file = std::make_shared<Image>(UDType::IMAGE, obj);
682 file->SetUri("uri");
683 file->SetRemoteUri("remoteUri");
684 data.AddRecord(file);
685 std::string key;
686 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
687 ASSERT_EQ(E_OK, status);
688
689 GetDataParams params;
690 QueryOption query = {
691 .intention = UD_INTENTION_DRAG,
692 .key = key
693 };
__anon0eb97f481202(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 694 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
695 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
696 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
697 if (data == nullptr) {
698 ASSERT_TRUE(progress.progress != 0);
699 return;
700 }
701 ASSERT_EQ(1, data->GetRecords().size());
702 LOG_INFO(UDMF_TEST, "CancelOnSingleTask001 callback end.");
703 };
704 params.query = query;
705 params.progressIndicator = ProgressIndicator::DEFAULT;
706 params.progressListener = callback;
707 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
708 ASSERT_EQ(E_OK, status);
709 status = UdmfAsyncClient::GetInstance().CancelOnSingleTask();
710 ASSERT_EQ(E_ERROR, status);
711
712 LOG_INFO(UDMF_TEST, "CancelOnSingleTask001 end.");
713 }
714
715 /* *
716 * @tc.name: CancelOnSingleTask002
717 * @tc.desc: Test no data
718 * @tc.type: FUNC
719 */
720 HWTEST_F(UdmfAsyncClientTest, CancelOnSingleTask002, TestSize.Level1)
721 {
722 LOG_INFO(UDMF_TEST, "CancelOnSingleTask002 begin.");
723 auto status = UdmfAsyncClient::GetInstance().CancelOnSingleTask();
724 ASSERT_EQ(E_ERROR, status);
725
726 LOG_INFO(UDMF_TEST, "CancelOnSingleTask002 end.");
727 }
728
729 /* *
730 * @tc.name: CancelOnSingleTask003
731 * @tc.desc: Test two data
732 * @tc.type: FUNC
733 */
734 HWTEST_F(UdmfAsyncClientTest, CancelOnSingleTask003, TestSize.Level1)
735 {
736 LOG_INFO(UDMF_TEST, "CancelOnSingleTask003 begin.");
737 CustomOption customOption = {
738 .intention = UDMF::UD_INTENTION_DRAG
739 };
740 UnifiedData data;
741 auto obj = std::make_shared<Object>();
742 auto file = std::make_shared<Image>(UDType::IMAGE, obj);
743 file->SetUri("uri");
744 file->SetRemoteUri("remoteUri");
745 data.AddRecord(file);
746 std::string key;
747 auto status = UdmfClient::GetInstance().SetData(customOption, data, key);
748 ASSERT_EQ(E_OK, status);
749
750 GetDataParams params;
751 QueryOption query = {
752 .intention = UD_INTENTION_DRAG,
753 .key = key
754 };
__anon0eb97f481302(ProgressInfo progress, std::shared_ptr<UnifiedData> data) 755 auto callback = [this](ProgressInfo progress, std::shared_ptr<UnifiedData> data) {
756 LOG_INFO(UDMF_TEST, "Callback begin status=%{public}d, progress=%{public}d, name=%{public}s.",
757 progress.progressStatus, progress.progress, progress.srcDevName.c_str());
758 if (data == nullptr) {
759 ASSERT_TRUE(progress.progress != 0);
760 return;
761 }
762 ASSERT_EQ(1, data->GetRecords().size());
763 LOG_INFO(UDMF_TEST, "CancelOnSingleTask001 callback end.");
764 };
765 params.query = query;
766 params.progressIndicator = ProgressIndicator::DEFAULT;
767 params.progressListener = callback;
768 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
769 ASSERT_EQ(E_OK, status);
770 query = {
771 .intention = UD_INTENTION_DRAG,
772 .key = "key"
773 };
774 params.query = query;
775 status = UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
776 ASSERT_EQ(E_OK, status);
777 status = UdmfAsyncClient::GetInstance().CancelOnSingleTask();
778 ASSERT_EQ(E_ERROR, status);
779
780 LOG_INFO(UDMF_TEST, "CancelOnSingleTask003 end.");
781 }
782
783 HWTEST_F(UdmfAsyncClientTest, UpdateOnSameProgressAfterInterval, TestSize.Level1)
784 {
785 LOG_INFO(UDMF_TEST, "UpdateOnSameProgressAfterInterval begin.");
786 std::string businessUdKey = "udmf://a/b/c";
787 GetDataParams params;
788 params.progressIndicator = ProgressIndicator::DEFAULT;
789 params.query.key = businessUdKey;
790 UdmfAsyncClient::GetInstance().RegisterAsyncHelper(params);
__anon0eb97f481402() 791 std::thread pushThread([&]() {
792 auto &asyncHelper = UdmfAsyncClient::GetInstance().asyncHelperMap_.at(businessUdKey);
793 for (uint32_t i = 0; i < 10; ++i) {
794 std::this_thread::sleep_for(std::chrono::milliseconds(100));
795 ProgressInfo sameProgress;
796 sameProgress.progress = 20;
797 asyncHelper->progressQueue.PushBack(sameProgress);
798 }
799 auto processKey = asyncHelper->processKey;
800 std::vector<UnifiedData> unifiedDataSet;
801 QueryOption query;
802 query.key = processKey;
803 auto ret = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
804 EXPECT_EQ(ret, E_OK);
805 ASSERT_EQ(unifiedDataSet.size(), 1);
806 auto record = unifiedDataSet[0].GetRecordAt(0);
807 EXPECT_EQ(record->GetType(), UDType::PLAIN_TEXT);
808 auto plainText = std::static_pointer_cast<PlainText>(record);
809 auto ts1 = plainText->GetAbstract();
810 for (uint32_t i = 0; i < 30; ++i) {
811 std::this_thread::sleep_for(std::chrono::milliseconds(100));
812 ProgressInfo sameProgress;
813 sameProgress.progress = 20;
814 asyncHelper->progressQueue.PushBack(sameProgress);
815 }
816 unifiedDataSet.clear();
817 ret = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
818 EXPECT_EQ(ret, E_OK);
819 ASSERT_EQ(unifiedDataSet.size(), 1);
820 record = unifiedDataSet[0].GetRecordAt(0);
821 EXPECT_EQ(record->GetType(), UDType::PLAIN_TEXT);
822 plainText = std::static_pointer_cast<PlainText>(record);
823 auto ts2 = plainText->GetAbstract();
824 EXPECT_TRUE(ts2 > ts1);
825 ProgressInfo sameProgress;
826 sameProgress.progress = 100;
827 asyncHelper->progressQueue.PushBack(sameProgress);
828 });
829 auto ret = UdmfAsyncClient::GetInstance().ProgressTask(businessUdKey);
830 EXPECT_EQ(ret, E_OK);
831 pushThread.join();
832 LOG_INFO(UDMF_TEST, "UpdateOnSameProgressAfterInterval end.");
833 }
834
835 } // OHOS::Test