1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "udmf_client_fuzzer.h"
17
18 #include <unistd.h>
19
20 #include "accesstoken_kit.h"
21 #include "nativetoken_kit.h"
22 #include "token_setproc.h"
23
24 #include "udmf_client.h"
25 #include "text.h"
26 #include "plain_text.h"
27 #include "html.h"
28 #include "link.h"
29 #include "file.h"
30 #include "image.h"
31 #include "video.h"
32 #include "system_defined_record.h"
33 #include "system_defined_form.h"
34 #include "system_defined_appitem.h"
35 #include "system_defined_pixelmap.h"
36 #include "udmf_async_client.h"
37 #include "unified_types.h"
38
39 using namespace OHOS;
40 using namespace OHOS::Security::AccessToken;
41 using namespace OHOS::UDMF;
42
43 namespace OHOS {
AllocHapToken()44 void AllocHapToken()
45 {
46 HapInfoParams info = {
47 .userID = 100,
48 .bundleName = "ohos.test.demo",
49 .instIndex = 0,
50 .appIDDesc = "ohos.test.demo"
51 };
52
53 HapPolicyParams policy = {
54 .apl = APL_NORMAL,
55 .domain = "test.domain",
56 .permList = {
57 {
58 .permissionName = "ohos.permission.test",
59 .bundleName = "ohos.test.demo",
60 .grantMode = 1,
61 .availableLevel = APL_NORMAL,
62 .label = "label",
63 .labelId = 1,
64 .description = "test",
65 .descriptionId = 1
66 }
67 },
68 .permStateList = {
69 {
70 .permissionName = "ohos.permission.test",
71 .isGeneral = true,
72 .resDeviceID = {"local"},
73 .grantStatus = {PermissionState::PERMISSION_GRANTED},
74 .grantFlags = {1}
75 }
76 }
77 };
78 auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
79 SetSelfTokenID(tokenID.tokenIDEx);
80 }
81
SetUpTestCase()82 void SetUpTestCase()
83 {
84 AllocHapToken();
85 }
86
TearDown()87 void TearDown()
88 {
89 }
90
SetNativeToken()91 void SetNativeToken()
92 {
93 NativeTokenInfoParams infoInstance = {
94 .dcapsNum = 0,
95 .permsNum = 0,
96 .aclsNum = 0,
97 .dcaps = nullptr,
98 .perms = nullptr,
99 .acls = nullptr,
100 .processName = "msdp_sa",
101 .aplStr = "system_core",
102 };
103 auto tokenId = GetAccessTokenId(&infoInstance);
104 SetSelfTokenID(tokenId);
105 AccessTokenKit::ReloadNativeTokenInfo();
106 }
107
SetHapToken()108 void SetHapToken()
109 {
110 auto tokenId = AccessTokenKit::GetHapTokenID(100, "ohos.test.demo", 0);
111 SetSelfTokenID(tokenId);
112 }
113
SetDataTextFuzz(const uint8_t * data,size_t size)114 void SetDataTextFuzz(const uint8_t *data, size_t size)
115 {
116 std::string skey(data, data + size);
117 std::string svalue(data, data + size);
118 UnifiedData unifiedData;
119 CustomOption option = {.intention = Intention::UD_INTENTION_BUTT};
120 auto text = std::make_shared<Text>();
121 UDDetails details;
122 details.insert({skey, svalue});
123 text->SetDetails(details);
124 unifiedData.AddRecord(text);
125 std::string key;
126 UdmfClient::GetInstance().SetData(option, unifiedData, key);
127
128 SetNativeToken();
129
130 QueryOption option2 = {.key = key};
131 Privilege privilege;
132 privilege.readPermission = "readPermission";
133 privilege.writePermission = "writePermission";
134 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
135
136 SetHapToken();
137
138 UnifiedData data2;
139 UdmfClient::GetInstance().GetData(option2, data2);
140 }
141
SetDataPlainTextFuzz(const uint8_t * data,size_t size)142 void SetDataPlainTextFuzz(const uint8_t *data, size_t size)
143 {
144 std::string skey(data, data + size);
145 std::string svalue(data, data + size);
146 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
147 UnifiedData data1;
148 UDDetails details1;
149 auto plainText1 = std::make_shared<PlainText>();
150 details1.insert({skey, svalue});
151 plainText1->SetDetails(details1);
152 plainText1->SetContent(svalue + "content");
153 plainText1->SetAbstract(svalue + "abstract");
154 plainText1->GetContent();
155 plainText1->GetAbstract();
156 data1.AddRecord(plainText1);
157 std::string key;
158 UdmfClient::GetInstance().SetData(option1, data1, key);
159
160 SetNativeToken();
161
162 QueryOption option2 = {.key = key};
163 Privilege privilege;
164 privilege.readPermission = "readPermission";
165 privilege.writePermission = "writePermission";
166 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
167
168 SetHapToken();
169
170 UnifiedData data2;
171 UdmfClient::GetInstance().GetData(option2, data2);
172 }
173
SetDataHtmlFuzz(const uint8_t * data,size_t size)174 void SetDataHtmlFuzz(const uint8_t *data, size_t size)
175 {
176 std::string skey(data, data + size);
177 std::string svalue(data, data + size);
178 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
179 UnifiedData data1;
180 std::string key;
181 auto html1 = std::make_shared<Html>();
182 UDDetails details1;
183 details1.insert({skey, svalue});
184 html1->SetDetails(details1);
185 html1->SetHtmlContent(svalue + "htmlcontent");
186 html1->SetPlainContent(svalue + "plainContent");
187 html1->GetHtmlContent();
188 html1->GetPlainContent();
189 data1.AddRecord(html1);
190 UdmfClient::GetInstance().SetData(option1, data1, key);
191
192 SetNativeToken();
193
194 QueryOption option2 = {.key = key};
195 Privilege privilege;
196 privilege.readPermission = "readPermission";
197 privilege.writePermission = "writePermission";
198 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
199
200 SetHapToken();
201
202 UnifiedData data2;
203 UdmfClient::GetInstance().GetData(option2, data2);
204 }
205
SetDataLinkFuzz(const uint8_t * data,size_t size)206 void SetDataLinkFuzz(const uint8_t *data, size_t size)
207 {
208 std::string skey(data, data + size);
209 std::string svalue(data, data + size);
210 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
211 UnifiedData data1;
212 std::string key;
213 auto link1 = std::make_shared<Link>();
214 UDDetails details1;
215 details1.insert({skey, svalue});
216 link1->SetDetails(details1);
217 link1->SetUrl(svalue + "url");
218 link1->SetDescription(svalue + "description");
219 link1->GetUrl();
220 link1->GetDescription();
221 data1.AddRecord(link1);
222 UdmfClient::GetInstance().SetData(option1, data1, key);
223
224 SetNativeToken();
225
226 QueryOption option2 = {.key = key};
227 Privilege privilege;
228 privilege.readPermission = "readPermission";
229 privilege.writePermission = "writePermission";
230 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
231
232 SetHapToken();
233
234 UnifiedData data2;
235 UdmfClient::GetInstance().GetData(option2, data2);
236 }
237
SetDataFileFuzz(const uint8_t * data,size_t size)238 void SetDataFileFuzz(const uint8_t *data, size_t size)
239 {
240 std::string svalue(data, data + size);
241 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
242 UnifiedData data1;
243 std::string key;
244 auto file1 = std::make_shared<File>();
245 file1->SetUri(svalue + "uri");
246 file1->SetRemoteUri(svalue + "remoteUri");
247 file1->GetUri();
248 file1->GetRemoteUri();
249 file1->GetSize();
250 data1.AddRecord(file1);
251 UdmfClient::GetInstance().SetData(option1, data1, key);
252
253 SetNativeToken();
254
255 QueryOption option2 = {.key = key};
256 Privilege privilege;
257 privilege.readPermission = "readPermission";
258 privilege.writePermission = "writePermission";
259 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
260
261 SetHapToken();
262
263 UnifiedData data2;
264 UdmfClient::GetInstance().GetData(option2, data2);
265 }
266
SetDataImageFuzz(const uint8_t * data,size_t size)267 void SetDataImageFuzz(const uint8_t *data, size_t size)
268 {
269 std::string svalue(data, data + size);
270 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
271 UnifiedData data1;
272 std::string key;
273 auto image1 = std::make_shared<Image>();
274 image1->SetUri(svalue + "uri");
275 image1->SetRemoteUri(svalue + "remoteUri");
276 data1.AddRecord(image1);
277 UdmfClient::GetInstance().SetData(option1, data1, key);
278
279 SetNativeToken();
280
281 QueryOption option2 = {.key = key};
282 Privilege privilege;
283 privilege.readPermission = "readPermission";
284 privilege.writePermission = "writePermission";
285 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
286
287 SetHapToken();
288
289 UnifiedData data2;
290 UdmfClient::GetInstance().GetData(option2, data2);
291 }
292
SetDataVideoFuzz(const uint8_t * data,size_t size)293 void SetDataVideoFuzz(const uint8_t *data, size_t size)
294 {
295 std::string svalue(data, data + size);
296 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
297 UnifiedData data1;
298 std::string key;
299 auto video1 = std::make_shared<Video>();
300 video1->SetUri(svalue + "uri");
301 video1->SetRemoteUri(svalue + "remoteUri");
302 data1.AddRecord(video1);
303 UdmfClient::GetInstance().SetData(option1, data1, key);
304
305 SetNativeToken();
306
307 QueryOption option2 = {.key = key};
308 Privilege privilege;
309 privilege.readPermission = "readPermission";
310 privilege.writePermission = "writePermission";
311 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
312
313 SetHapToken();
314
315 UnifiedData data2;
316 UdmfClient::GetInstance().GetData(option2, data2);
317 }
318
SetDataSystemDefinedRecordFuzz(const uint8_t * data,size_t size)319 void SetDataSystemDefinedRecordFuzz(const uint8_t *data, size_t size)
320 {
321 std::string skey(data, data + size);
322 std::string svalue(data, data + size);
323 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
324 UnifiedData data1;
325 std::string key;
326 auto systemDefinedRecord1 = std::make_shared<SystemDefinedRecord>();
327 UDDetails details1;
328 details1.insert({skey, svalue});
329 systemDefinedRecord1->SetDetails(details1);
330 data1.AddRecord(systemDefinedRecord1);
331 UdmfClient::GetInstance().SetData(option1, data1, key);
332
333 SetNativeToken();
334
335 QueryOption option2 = {.key = key};
336 Privilege privilege;
337 privilege.readPermission = "readPermission";
338 privilege.writePermission = "writePermission";
339 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
340
341 SetHapToken();
342
343 UnifiedData data2;
344 UdmfClient::GetInstance().GetData(option2, data2);
345 }
346
SetDataSystemDefinedFormFuzz(const uint8_t * data,size_t size)347 void SetDataSystemDefinedFormFuzz(const uint8_t *data, size_t size)
348 {
349 std::string skey(data, data + size);
350 std::string svalue(data, data + size);
351 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
352 UnifiedData data1;
353 std::string key;
354 auto systemDefinedForm1 = std::make_shared<SystemDefinedForm>();
355 UDDetails details1;
356 details1.insert({skey, svalue});
357 systemDefinedForm1->SetDetails(details1);
358 auto formId = 123;
359 systemDefinedForm1->SetFormId(formId);
360 systemDefinedForm1->SetFormName(svalue + "formName");
361 systemDefinedForm1->SetModule(svalue + "module");
362 systemDefinedForm1->SetAbilityName(svalue + "abilityName");
363 systemDefinedForm1->SetBundleName(svalue + "bundleName");
364 systemDefinedForm1->GetFormId();
365 systemDefinedForm1->GetFormName();
366 systemDefinedForm1->GetBundleName();
367 systemDefinedForm1->GetAbilityName();
368 systemDefinedForm1->GetModule();
369 data1.AddRecord(systemDefinedForm1);
370 UdmfClient::GetInstance().SetData(option1, data1, key);
371
372 SetNativeToken();
373
374 QueryOption option2 = {.key = key};
375 Privilege privilege;
376 privilege.readPermission = "readPermission";
377 privilege.writePermission = "writePermission";
378 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
379
380 SetHapToken();
381
382 UnifiedData data2;
383 UdmfClient::GetInstance().GetData(option2, data2);
384 }
385
SetDataSystemDefinedAppItemFuzz(const uint8_t * data,size_t size)386 void SetDataSystemDefinedAppItemFuzz(const uint8_t *data, size_t size)
387 {
388 std::string skey(data, data + size);
389 std::string svalue(data, data + size);
390 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
391 UnifiedData data1;
392 std::string key;
393 auto systemDefinedAppItem1 = std::make_shared<SystemDefinedAppItem>();
394 UDDetails details1;
395 details1.insert({skey, svalue});
396 systemDefinedAppItem1->SetDetails(details1);
397 systemDefinedAppItem1->SetAppId(svalue + "appId");
398 systemDefinedAppItem1->SetAppName(svalue + "appName");
399 systemDefinedAppItem1->SetAppIconId(svalue + "appIconId");
400 systemDefinedAppItem1->SetAppLabelId(svalue + "appLabelId");
401 systemDefinedAppItem1->SetBundleName(svalue + "bundleName");
402 systemDefinedAppItem1->SetAbilityName(svalue + "abilityName");
403 systemDefinedAppItem1->GetAppId();
404 systemDefinedAppItem1->GetAppName();
405 systemDefinedAppItem1->GetBundleName();
406 systemDefinedAppItem1->GetAbilityName();
407 systemDefinedAppItem1->GetAppIconId();
408 systemDefinedAppItem1->GetAppLabelId();
409 data1.AddRecord(systemDefinedAppItem1);
410 UdmfClient::GetInstance().SetData(option1, data1, key);
411
412 SetNativeToken();
413
414 QueryOption option2 = {.key = key};
415 Privilege privilege;
416 privilege.readPermission = "readPermission";
417 privilege.writePermission = "writePermission";
418 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
419
420 SetHapToken();
421
422 UnifiedData data2;
423 UdmfClient::GetInstance().GetData(option2, data2);
424 }
425
SetDataSystemDefinedPixelMapFuzz(const uint8_t * data,size_t size)426 void SetDataSystemDefinedPixelMapFuzz(const uint8_t *data, size_t size)
427 {
428 std::string skey(data, data + size);
429 std::string svalue(data, data + size);
430 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
431 UnifiedData data1;
432 std::string key;
433 auto systemDefinedPixelMap1 = std::make_shared<SystemDefinedPixelMap>();
434 UDDetails details1;
435 details1.insert({skey, svalue});
436 systemDefinedPixelMap1->SetDetails(details1);
437 std::vector<uint8_t> rawData1 = {1, 2, 3, 4, 5};
438 systemDefinedPixelMap1->SetRawData(rawData1);
439 data1.AddRecord(systemDefinedPixelMap1);
440 UdmfClient::GetInstance().SetData(option1, data1, key);
441
442 SetNativeToken();
443
444 QueryOption option2 = {.key = key};
445 Privilege privilege;
446 privilege.readPermission = "readPermission";
447 privilege.writePermission = "writePermission";
448 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
449
450 SetHapToken();
451
452 UnifiedData data2;
453 UdmfClient::GetInstance().GetData(option2, data2);
454 }
455
GetSummaryFuzz(const uint8_t * data,size_t size)456 void GetSummaryFuzz(const uint8_t *data, size_t size)
457 {
458 std::string skey(data, data + size);
459 std::string svalue(data, data + size);
460 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
461 UnifiedData UData;
462 std::string key;
463
464 UDDetails details;
465 details.insert({skey, svalue});
466
467 auto text = std::make_shared<Text>();
468 text->SetDetails(details);
469 UData.AddRecord(text);
470
471 auto plainText = std::make_shared<PlainText>();
472 plainText->SetDetails(details);
473 plainText->SetContent(svalue + "content");
474 plainText->SetAbstract(svalue + "abstract");
475 UData.AddRecord(plainText);
476
477 auto file = std::make_shared<File>();
478 file->SetUri(svalue + "uri");
479 file->SetRemoteUri(svalue + "remoteUri");
480 UData.AddRecord(file);
481
482 auto image = std::make_shared<Image>();
483 image->SetUri(svalue + "uri");
484 image->SetRemoteUri(svalue + "remoteUri");
485 UData.AddRecord(image);
486
487 auto systemDefinedRecord = std::make_shared<SystemDefinedRecord>();
488 systemDefinedRecord->SetDetails(details);
489 UData.AddRecord(systemDefinedRecord);
490
491 auto systemDefinedForm = std::make_shared<SystemDefinedForm>();
492 systemDefinedForm->SetDetails(details);
493 auto formId = 123;
494 systemDefinedForm->SetFormId(formId);
495 systemDefinedForm->SetFormName(svalue + "formName");
496 systemDefinedForm->SetModule(svalue + "module");
497 systemDefinedForm->SetAbilityName(svalue + "abilityName");
498 systemDefinedForm->SetBundleName(svalue + "bundleName");
499 UData.AddRecord(systemDefinedForm);
500
501 UdmfClient::GetInstance().SetData(option1, UData, key);
502
503 QueryOption option2 = {.key = key};
504 Summary summary;
505 UdmfClient::GetInstance().GetSummary(option2, summary);
506 UnifiedData data2;
507 UdmfClient::GetInstance().GetData(option2, data2);
508 }
509
GetBatchDataByKeyFuzz(const uint8_t * data,size_t size)510 void GetBatchDataByKeyFuzz(const uint8_t *data, size_t size)
511 {
512 std::string skey(data, data + size);
513 CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
514 UnifiedData data1;
515 std::string key;
516 auto plainText = std::make_shared<PlainText>();
517 data1.AddRecord(plainText);
518 UdmfClient::GetInstance().SetData(option1, data1, key);
519
520 SetHapToken();
521 QueryOption option2 = { .key = key };
522 std::vector<UnifiedData> dataSet2;
523 UdmfClient::GetInstance().GetBatchData(option2, dataSet2);
524
525 SetHapToken();
526 QueryOption option3 = { .key = skey };
527 std::vector<UnifiedData> dataSet3;
528 UdmfClient::GetInstance().GetBatchData(option3, dataSet3);
529 }
530
GetBatchDataByIntentionFuzz(const uint8_t * data,size_t size)531 void GetBatchDataByIntentionFuzz(const uint8_t *data, size_t size)
532 {
533 std::string skey(data, data + size);
534 CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
535 UnifiedData data1;
536 std::string key;
537 auto plainText = std::make_shared<PlainText>();
538 data1.AddRecord(plainText);
539 UdmfClient::GetInstance().SetData(option1, data1, key);
540
541 SetHapToken();
542 Intention intention = UnifiedDataUtils::GetIntentionByString(skey);
543 QueryOption option2 = { .intention = intention };
544 std::vector<UnifiedData> dataSet;
545 UdmfClient::GetInstance().GetBatchData(option2, dataSet);
546 }
547
DeleteDataByKeyFuzz(const uint8_t * data,size_t size)548 void DeleteDataByKeyFuzz(const uint8_t *data, size_t size)
549 {
550 std::string skey(data, data + size);
551 CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
552 UnifiedData data1;
553 std::string key;
554 auto plainText = std::make_shared<PlainText>();
555 data1.AddRecord(plainText);
556 UdmfClient::GetInstance().SetData(option1, data1, key);
557
558 SetHapToken();
559 QueryOption option2 = { .key = key };
560 std::vector<UnifiedData> dataSet2;
561 UdmfClient::GetInstance().DeleteData(option2, dataSet2);
562
563 SetHapToken();
564 QueryOption option3 = { .key = skey };
565 std::vector<UnifiedData> dataSet3;
566 UdmfClient::GetInstance().DeleteData(option3, dataSet3);
567 }
568
DeleteDataByIntentionFuzz(const uint8_t * data,size_t size)569 void DeleteDataByIntentionFuzz(const uint8_t *data, size_t size)
570 {
571 std::string skey(data, data + size);
572 CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
573 UnifiedData data1;
574 std::string key;
575 auto plainText = std::make_shared<PlainText>();
576 data1.AddRecord(plainText);
577 UdmfClient::GetInstance().SetData(option1, data1, key);
578
579 SetHapToken();
580 Intention intention = UnifiedDataUtils::GetIntentionByString(skey);
581 QueryOption option2 = { .intention = intention };
582 std::vector<UnifiedData> dataSet;
583 UdmfClient::GetInstance().DeleteData(option2, dataSet);
584 }
585
UpdateDataFuzz(const uint8_t * data,size_t size)586 void UpdateDataFuzz(const uint8_t *data, size_t size)
587 {
588 std::string skey(data, data + size);
589 CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
590 UnifiedData data1;
591 std::string key;
592 auto plainText = std::make_shared<PlainText>();
593 data1.AddRecord(plainText);
594 UdmfClient::GetInstance().SetData(option1, data1, key);
595
596 SetHapToken();
597 UnifiedData data2;
598 data2.AddRecord(plainText);
599 QueryOption option2 = { .key = key };
600 UdmfClient::GetInstance().UpdateData(option2, data2);
601
602 SetHapToken();
603 UnifiedData data3;
604 data3.AddRecord(plainText);
605 QueryOption option3 = { .key = skey };
606 UdmfClient::GetInstance().UpdateData(option3, data3);
607 }
608
StartAsyncDataRetrievalFuzz(const uint8_t * data,size_t size)609 void StartAsyncDataRetrievalFuzz(const uint8_t *data, size_t size)
610 {
611 CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
612 UnifiedData data1;
613 std::string key;
614 auto plainText = std::make_shared<PlainText>();
615 std::string content(data, data + size);
616 plainText->SetContent(content);
617 data1.AddRecord(plainText);
618 UdmfClient::GetInstance().SetData(option1, data1, key);
619
620 QueryOption query = {.key = key, .intention = UDMF::UD_INTENTION_DRAG};
621 GetDataParams params = {.query = query};
622 params.progressIndicator = ProgressIndicator::DEFAULT;
623 params.progressListener = [](ProgressInfo progressInfo, std::shared_ptr<UnifiedData> data) {};
624 UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
625 std::this_thread::sleep_for(std::chrono::seconds(1));
626 }
627
CancelAsyncDataRetrievalFuzz(const uint8_t * data,size_t size)628 void CancelAsyncDataRetrievalFuzz(const uint8_t *data, size_t size)
629 {
630 CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
631 UnifiedData data1;
632 std::string key;
633 auto plainText = std::make_shared<PlainText>();
634 std::string content(data, data + size);
635 plainText->SetContent(content);
636 data1.AddRecord(plainText);
637 UdmfClient::GetInstance().SetData(option1, data1, key);
638
639 QueryOption query = {.key = key, .intention = UDMF::UD_INTENTION_DRAG};
640 GetDataParams params = {.query = query};
641 params.progressIndicator = ProgressIndicator::NONE;
642 params.progressListener = [](ProgressInfo progressInfo, std::shared_ptr<UnifiedData> data) {
643 std::this_thread::sleep_for(std::chrono::milliseconds(500));
644 };
645 UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
646 UdmfAsyncClient::GetInstance().Cancel(key);
647 std::this_thread::sleep_for(std::chrono::seconds(1));
648 }
649 }
650
651 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)652 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
653 {
654 /* Run your code on data */
655 OHOS::SetUpTestCase();
656 OHOS::SetDataFileFuzz(data, size);
657 OHOS::SetDataHtmlFuzz(data, size);
658 OHOS::SetDataImageFuzz(data, size);
659 OHOS::SetDataLinkFuzz(data, size);
660 OHOS::SetDataPlainTextFuzz(data, size);
661 OHOS::SetDataSystemDefinedAppItemFuzz(data, size);
662 OHOS::SetDataSystemDefinedFormFuzz(data, size);
663 OHOS::SetDataSystemDefinedPixelMapFuzz(data, size);
664 OHOS::SetDataSystemDefinedRecordFuzz(data, size);
665 OHOS::SetDataTextFuzz(data, size);
666 OHOS::SetDataVideoFuzz(data, size);
667 OHOS::GetSummaryFuzz(data, size);
668 OHOS::GetBatchDataByKeyFuzz(data, size);
669 OHOS::GetBatchDataByIntentionFuzz(data, size);
670 OHOS::DeleteDataByKeyFuzz(data, size);
671 OHOS::DeleteDataByIntentionFuzz(data, size);
672 OHOS::UpdateDataFuzz(data, size);
673 OHOS::StartAsyncDataRetrievalFuzz(data, size);
674 OHOS::CancelAsyncDataRetrievalFuzz(data, size);
675 OHOS::TearDown();
676 return 0;
677 }