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 
37 using namespace OHOS;
38 using namespace OHOS::Security::AccessToken;
39 using namespace OHOS::UDMF;
40 
41 namespace OHOS {
AllocHapToken()42 void AllocHapToken()
43 {
44     HapInfoParams info = {
45         .userID = 100,
46         .bundleName = "ohos.test.demo",
47         .instIndex = 0,
48         .appIDDesc = "ohos.test.demo"
49     };
50 
51     HapPolicyParams policy = {
52         .apl = APL_NORMAL,
53         .domain = "test.domain",
54         .permList = {
55             {
56                 .permissionName = "ohos.permission.test",
57                 .bundleName = "ohos.test.demo",
58                 .grantMode = 1,
59                 .availableLevel = APL_NORMAL,
60                 .label = "label",
61                 .labelId = 1,
62                 .description = "test",
63                 .descriptionId = 1
64             }
65         },
66         .permStateList = {
67             {
68                 .permissionName = "ohos.permission.test",
69                 .isGeneral = true,
70                 .resDeviceID = {"local"},
71                 .grantStatus = {PermissionState::PERMISSION_GRANTED},
72                 .grantFlags = {1}
73             }
74         }
75     };
76     auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
77     SetSelfTokenID(tokenID.tokenIDEx);
78 }
79 
SetUpTestCase()80 void SetUpTestCase()
81 {
82     AllocHapToken();
83 }
84 
TearDown()85 void TearDown()
86 {
87 }
88 
SetNativeToken()89 void SetNativeToken()
90 {
91     NativeTokenInfoParams infoInstance = {
92         .dcapsNum = 0,
93         .permsNum = 0,
94         .aclsNum = 0,
95         .dcaps = nullptr,
96         .perms = nullptr,
97         .acls = nullptr,
98         .processName = "msdp_sa",
99         .aplStr = "system_core",
100     };
101     auto tokenId = GetAccessTokenId(&infoInstance);
102     SetSelfTokenID(tokenId);
103     AccessTokenKit::ReloadNativeTokenInfo();
104 }
105 
SetHapToken()106 void SetHapToken()
107 {
108     auto tokenId = AccessTokenKit::GetHapTokenID(100, "ohos.test.demo", 0);
109     SetSelfTokenID(tokenId);
110 }
111 
SetDataTextFuzz(const uint8_t * data,size_t size)112 void SetDataTextFuzz(const uint8_t *data, size_t size)
113 {
114     std::string skey(data, data + size);
115     std::string svalue(data, data + size);
116     UnifiedData unifiedData;
117     CustomOption option = {.intention = Intention::UD_INTENTION_BUTT};
118     Text text;
119     UDDetails details;
120     details.insert({skey, svalue});
121     text.SetDetails(details);
122     std::shared_ptr<UnifiedRecord> record = std::make_shared<Text>(text);
123     unifiedData.AddRecord(record);
124     std::string key;
125     UdmfClient::GetInstance().SetData(option, unifiedData, key);
126 
127     SetNativeToken();
128 
129     QueryOption option2 = {.key = key};
130     Privilege privilege;
131     privilege.readPermission = "readPermission";
132     privilege.writePermission = "writePermission";
133     UdmfClient::GetInstance().AddPrivilege(option2, privilege);
134 
135     SetHapToken();
136 
137     UnifiedData data2;
138     UdmfClient::GetInstance().GetData(option2, data2);
139 }
140 
SetDataPlainTextFuzz(const uint8_t * data,size_t size)141 void SetDataPlainTextFuzz(const uint8_t *data, size_t size)
142 {
143     std::string skey(data, data + size);
144     std::string svalue(data, data + size);
145     CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
146     UnifiedData data1;
147     PlainText plainText1;
148     UDDetails details1;
149     details1.insert({skey, svalue});
150     plainText1.SetDetails(details1);
151     plainText1.SetContent(svalue + "content");
152     plainText1.SetAbstract(svalue + "abstract");
153     plainText1.GetContent();
154     plainText1.GetAbstract();
155     std::shared_ptr<UnifiedRecord> record1 = std::make_shared<PlainText>(plainText1);
156     data1.AddRecord(record1);
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     Html html1;
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     std::shared_ptr<UnifiedRecord> record1 = std::make_shared<Html>(html1);
190     data1.AddRecord(record1);
191     UdmfClient::GetInstance().SetData(option1, data1, key);
192 
193     SetNativeToken();
194 
195     QueryOption option2 = {.key = key};
196     Privilege privilege;
197     privilege.readPermission = "readPermission";
198     privilege.writePermission = "writePermission";
199     UdmfClient::GetInstance().AddPrivilege(option2, privilege);
200 
201     SetHapToken();
202 
203     UnifiedData data2;
204     UdmfClient::GetInstance().GetData(option2, data2);
205 }
206 
SetDataLinkFuzz(const uint8_t * data,size_t size)207 void SetDataLinkFuzz(const uint8_t *data, size_t size)
208 {
209     std::string skey(data, data + size);
210     std::string svalue(data, data + size);
211     CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
212     UnifiedData data1;
213     std::string key;
214     Link link1;
215     UDDetails details1;
216     details1.insert({skey, svalue});
217     link1.SetDetails(details1);
218     link1.SetUrl(svalue + "url");
219     link1.SetDescription(svalue + "description");
220     link1.GetUrl();
221     link1.GetDescription();
222     std::shared_ptr<UnifiedRecord> record1 = std::make_shared<Link>(link1);
223     data1.AddRecord(record1);
224     UdmfClient::GetInstance().SetData(option1, data1, key);
225 
226     SetNativeToken();
227 
228     QueryOption option2 = {.key = key};
229     Privilege privilege;
230     privilege.readPermission = "readPermission";
231     privilege.writePermission = "writePermission";
232     UdmfClient::GetInstance().AddPrivilege(option2, privilege);
233 
234     SetHapToken();
235 
236     UnifiedData data2;
237     UdmfClient::GetInstance().GetData(option2, data2);
238 }
239 
SetDataFileFuzz(const uint8_t * data,size_t size)240 void SetDataFileFuzz(const uint8_t *data, size_t size)
241 {
242     std::string svalue(data, data + size);
243     CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
244     UnifiedData data1;
245     std::string key;
246     File file1;
247     file1.SetUri(svalue + "uri");
248     file1.SetRemoteUri(svalue + "remoteUri");
249     file1.GetUri();
250     file1.GetRemoteUri();
251     file1.GetSize();
252     std::shared_ptr<UnifiedRecord> record1 = std::make_shared<File>(file1);
253     data1.AddRecord(record1);
254     UdmfClient::GetInstance().SetData(option1, data1, key);
255 
256     SetNativeToken();
257 
258     QueryOption option2 = {.key = key};
259     Privilege privilege;
260     privilege.readPermission = "readPermission";
261     privilege.writePermission = "writePermission";
262     UdmfClient::GetInstance().AddPrivilege(option2, privilege);
263 
264     SetHapToken();
265 
266     UnifiedData data2;
267     UdmfClient::GetInstance().GetData(option2, data2);
268 }
269 
SetDataImageFuzz(const uint8_t * data,size_t size)270 void SetDataImageFuzz(const uint8_t *data, size_t size)
271 {
272     std::string svalue(data, data + size);
273     CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
274     UnifiedData data1;
275     std::string key;
276     Image image1;
277     image1.SetUri(svalue + "uri");
278     image1.SetRemoteUri(svalue + "remoteUri");
279     std::shared_ptr<UnifiedRecord> record1 = std::make_shared<Image>(image1);
280     data1.AddRecord(record1);
281     UdmfClient::GetInstance().SetData(option1, data1, key);
282 
283     SetNativeToken();
284 
285     QueryOption option2 = {.key = key};
286     Privilege privilege;
287     privilege.readPermission = "readPermission";
288     privilege.writePermission = "writePermission";
289     UdmfClient::GetInstance().AddPrivilege(option2, privilege);
290 
291     SetHapToken();
292 
293     UnifiedData data2;
294     UdmfClient::GetInstance().GetData(option2, data2);
295 }
296 
SetDataVideoFuzz(const uint8_t * data,size_t size)297 void SetDataVideoFuzz(const uint8_t *data, size_t size)
298 {
299     std::string svalue(data, data + size);
300     CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
301     UnifiedData data1;
302     std::string key;
303     Video video1;
304     video1.SetUri(svalue + "uri");
305     video1.SetRemoteUri(svalue + "remoteUri");
306     std::shared_ptr<UnifiedRecord> record1 = std::make_shared<Video>(video1);
307     data1.AddRecord(record1);
308     UdmfClient::GetInstance().SetData(option1, data1, key);
309 
310     SetNativeToken();
311 
312     QueryOption option2 = {.key = key};
313     Privilege privilege;
314     privilege.readPermission = "readPermission";
315     privilege.writePermission = "writePermission";
316     UdmfClient::GetInstance().AddPrivilege(option2, privilege);
317 
318     SetHapToken();
319 
320     UnifiedData data2;
321     UdmfClient::GetInstance().GetData(option2, data2);
322 }
323 
SetDataSystemDefinedRecordFuzz(const uint8_t * data,size_t size)324 void SetDataSystemDefinedRecordFuzz(const uint8_t *data, size_t size)
325 {
326     std::string skey(data, data + size);
327     std::string svalue(data, data + size);
328     CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
329     UnifiedData data1;
330     std::string key;
331     SystemDefinedRecord systemDefinedRecord1;
332     UDDetails details1;
333     details1.insert({skey, svalue});
334     systemDefinedRecord1.SetDetails(details1);
335     std::shared_ptr<UnifiedRecord> record1 = std::make_shared<SystemDefinedRecord>(systemDefinedRecord1);
336     data1.AddRecord(record1);
337     UdmfClient::GetInstance().SetData(option1, data1, key);
338 
339     SetNativeToken();
340 
341     QueryOption option2 = {.key = key};
342     Privilege privilege;
343     privilege.readPermission = "readPermission";
344     privilege.writePermission = "writePermission";
345     UdmfClient::GetInstance().AddPrivilege(option2, privilege);
346 
347     SetHapToken();
348 
349     UnifiedData data2;
350     UdmfClient::GetInstance().GetData(option2, data2);
351 }
352 
SetDataSystemDefinedFormFuzz(const uint8_t * data,size_t size)353 void SetDataSystemDefinedFormFuzz(const uint8_t *data, size_t size)
354 {
355     std::string skey(data, data + size);
356     std::string svalue(data, data + size);
357     CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
358     UnifiedData data1;
359     std::string key;
360     SystemDefinedForm systemDefinedForm1;
361     UDDetails details1;
362     details1.insert({skey, svalue});
363     systemDefinedForm1.SetDetails(details1);
364     auto formId = 123;
365     systemDefinedForm1.SetFormId(formId);
366     systemDefinedForm1.SetFormName(svalue + "formName");
367     systemDefinedForm1.SetModule(svalue + "module");
368     systemDefinedForm1.SetAbilityName(svalue + "abilityName");
369     systemDefinedForm1.SetBundleName(svalue + "bundleName");
370     systemDefinedForm1.GetFormId();
371     systemDefinedForm1.GetFormName();
372     systemDefinedForm1.GetBundleName();
373     systemDefinedForm1.GetAbilityName();
374     systemDefinedForm1.GetModule();
375     std::shared_ptr<UnifiedRecord> record1 = std::make_shared<SystemDefinedForm>(systemDefinedForm1);
376     data1.AddRecord(record1);
377     UdmfClient::GetInstance().SetData(option1, data1, key);
378 
379     SetNativeToken();
380 
381     QueryOption option2 = {.key = key};
382     Privilege privilege;
383     privilege.readPermission = "readPermission";
384     privilege.writePermission = "writePermission";
385     UdmfClient::GetInstance().AddPrivilege(option2, privilege);
386 
387     SetHapToken();
388 
389     UnifiedData data2;
390     UdmfClient::GetInstance().GetData(option2, data2);
391 }
392 
SetDataSystemDefinedAppItemFuzz(const uint8_t * data,size_t size)393 void SetDataSystemDefinedAppItemFuzz(const uint8_t *data, size_t size)
394 {
395     std::string skey(data, data + size);
396     std::string svalue(data, data + size);
397     CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
398     UnifiedData data1;
399     std::string key;
400     SystemDefinedAppItem systemDefinedAppItem1;
401     UDDetails details1;
402     details1.insert({skey, svalue});
403     systemDefinedAppItem1.SetDetails(details1);
404     systemDefinedAppItem1.SetAppId(svalue + "appId");
405     systemDefinedAppItem1.SetAppName(svalue + "appName");
406     systemDefinedAppItem1.SetAppIconId(svalue + "appIconId");
407     systemDefinedAppItem1.SetAppLabelId(svalue + "appLabelId");
408     systemDefinedAppItem1.SetBundleName(svalue + "bundleName");
409     systemDefinedAppItem1.SetAbilityName(svalue + "abilityName");
410     systemDefinedAppItem1.GetAppId();
411     systemDefinedAppItem1.GetAppName();
412     systemDefinedAppItem1.GetBundleName();
413     systemDefinedAppItem1.GetAbilityName();
414     systemDefinedAppItem1.GetAppIconId();
415     systemDefinedAppItem1.GetAppLabelId();
416     std::shared_ptr<UnifiedRecord> record1 = std::make_shared<SystemDefinedAppItem>(systemDefinedAppItem1);
417     data1.AddRecord(record1);
418     UdmfClient::GetInstance().SetData(option1, data1, key);
419 
420     SetNativeToken();
421 
422     QueryOption option2 = {.key = key};
423     Privilege privilege;
424     privilege.readPermission = "readPermission";
425     privilege.writePermission = "writePermission";
426     UdmfClient::GetInstance().AddPrivilege(option2, privilege);
427 
428     SetHapToken();
429 
430     UnifiedData data2;
431     UdmfClient::GetInstance().GetData(option2, data2);
432 }
433 
SetDataSystemDefinedPixelMapFuzz(const uint8_t * data,size_t size)434 void SetDataSystemDefinedPixelMapFuzz(const uint8_t *data, size_t size)
435 {
436     std::string skey(data, data + size);
437     std::string svalue(data, data + size);
438     CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
439     UnifiedData data1;
440     std::string key;
441     SystemDefinedPixelMap systemDefinedPixelMap1;
442     UDDetails details1;
443     details1.insert({skey, svalue});
444     systemDefinedPixelMap1.SetDetails(details1);
445     std::vector<uint8_t> rawData1 = {1, 2, 3, 4, 5};
446     systemDefinedPixelMap1.SetRawData(rawData1);
447     std::shared_ptr<UnifiedRecord> record1 = std::make_shared<SystemDefinedPixelMap>(systemDefinedPixelMap1);
448     data1.AddRecord(record1);
449     UdmfClient::GetInstance().SetData(option1, data1, key);
450 
451     SetNativeToken();
452 
453     QueryOption option2 = {.key = key};
454     Privilege privilege;
455     privilege.readPermission = "readPermission";
456     privilege.writePermission = "writePermission";
457     UdmfClient::GetInstance().AddPrivilege(option2, privilege);
458 
459     SetHapToken();
460 
461     UnifiedData data2;
462     UdmfClient::GetInstance().GetData(option2, data2);
463 }
464 
GetSummaryFuzz(const uint8_t * data,size_t size)465 void GetSummaryFuzz(const uint8_t *data, size_t size)
466 {
467     std::string skey(data, data + size);
468     std::string svalue(data, data + size);
469     CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
470     UnifiedData UData;
471     std::string key;
472 
473     UDDetails details;
474     details.insert({skey, svalue});
475 
476     Text text;
477     text.SetDetails(details);
478     std::shared_ptr<UnifiedRecord> record1 = std::make_shared<Text>(text);
479     UData.AddRecord(record1);
480 
481     PlainText plainText;
482     plainText.SetDetails(details);
483     plainText.SetContent(svalue + "content");
484     plainText.SetAbstract(svalue + "abstract");
485     std::shared_ptr<UnifiedRecord> record2 = std::make_shared<PlainText>(plainText);
486     UData.AddRecord(record2);
487 
488     File file;
489     file.SetUri(svalue + "uri");
490     file.SetRemoteUri(svalue + "remoteUri");
491     std::shared_ptr<UnifiedRecord> record3 = std::make_shared<File>(file);
492     UData.AddRecord(record3);
493 
494     Image image;
495     image.SetUri(svalue + "uri");
496     image.SetRemoteUri(svalue + "remoteUri");
497     std::shared_ptr<UnifiedRecord> record4 = std::make_shared<Image>(image);
498     UData.AddRecord(record4);
499 
500     SystemDefinedRecord systemDefinedRecord;
501     systemDefinedRecord.SetDetails(details);
502     std::shared_ptr<UnifiedRecord> record5 = std::make_shared<SystemDefinedRecord>(systemDefinedRecord);
503     UData.AddRecord(record5);
504 
505     SystemDefinedForm systemDefinedForm;
506     systemDefinedForm.SetDetails(details);
507     auto formId = 123;
508     systemDefinedForm.SetFormId(formId);
509     systemDefinedForm.SetFormName(svalue + "formName");
510     systemDefinedForm.SetModule(svalue + "module");
511     systemDefinedForm.SetAbilityName(svalue + "abilityName");
512     systemDefinedForm.SetBundleName(svalue + "bundleName");
513     std::shared_ptr<UnifiedRecord> record6 = std::make_shared<SystemDefinedForm>(systemDefinedForm);
514     UData.AddRecord(record6);
515 
516     UdmfClient::GetInstance().SetData(option1, UData, key);
517 
518     QueryOption option2 = {.key = key};
519     Summary summary;
520     UdmfClient::GetInstance().GetSummary(option2, summary);
521     UnifiedData data2;
522     UdmfClient::GetInstance().GetData(option2, data2);
523 }
524 
GetBatchDataByKeyFuzz(const uint8_t * data,size_t size)525 void GetBatchDataByKeyFuzz(const uint8_t *data, size_t size)
526 {
527     std::string skey(data, data + size);
528     CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
529     UnifiedData data1;
530     std::string key;
531     PlainText plainText(skey, skey);
532     std::shared_ptr<UnifiedRecord> record1 = std::make_shared<PlainText>(plainText);
533     data1.AddRecord(record1);
534     UdmfClient::GetInstance().SetData(option1, data1, key);
535 
536     SetHapToken();
537     QueryOption option2 = { .key = key };
538     std::vector<UnifiedData> dataSet2;
539     UdmfClient::GetInstance().GetBatchData(option2, dataSet2);
540 
541     SetHapToken();
542     QueryOption option3 = { .key = skey };
543     std::vector<UnifiedData> dataSet3;
544     UdmfClient::GetInstance().GetBatchData(option3, dataSet3);
545 }
546 
GetBatchDataByIntentionFuzz(const uint8_t * data,size_t size)547 void GetBatchDataByIntentionFuzz(const uint8_t *data, size_t size)
548 {
549     std::string skey(data, data + size);
550     CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
551     UnifiedData data1;
552     std::string key;
553     PlainText plainText(skey, skey);
554     std::shared_ptr<UnifiedRecord> record1 = std::make_shared<PlainText>(plainText);
555     data1.AddRecord(record1);
556     UdmfClient::GetInstance().SetData(option1, data1, key);
557 
558     SetHapToken();
559     Intention intention = UnifiedDataUtils::GetIntentionByString(skey);
560     QueryOption option2 = { .intention = intention };
561     std::vector<UnifiedData> dataSet;
562     UdmfClient::GetInstance().GetBatchData(option2, dataSet);
563 }
564 
DeleteDataByKeyFuzz(const uint8_t * data,size_t size)565 void DeleteDataByKeyFuzz(const uint8_t *data, size_t size)
566 {
567     std::string skey(data, data + size);
568     CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
569     UnifiedData data1;
570     std::string key;
571     PlainText plainText(skey, skey);
572     std::shared_ptr<UnifiedRecord> record1 = std::make_shared<PlainText>(plainText);
573     data1.AddRecord(record1);
574     UdmfClient::GetInstance().SetData(option1, data1, key);
575 
576     SetHapToken();
577     QueryOption option2 = { .key = key };
578     std::vector<UnifiedData> dataSet2;
579     UdmfClient::GetInstance().DeleteData(option2, dataSet2);
580 
581     SetHapToken();
582     QueryOption option3 = { .key = skey };
583     std::vector<UnifiedData> dataSet3;
584     UdmfClient::GetInstance().DeleteData(option3, dataSet3);
585 }
586 
DeleteDataByIntentionFuzz(const uint8_t * data,size_t size)587 void DeleteDataByIntentionFuzz(const uint8_t *data, size_t size)
588 {
589     std::string skey(data, data + size);
590     CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
591     UnifiedData data1;
592     std::string key;
593     PlainText plainText(skey, skey);
594     std::shared_ptr<UnifiedRecord> record1 = std::make_shared<PlainText>(plainText);
595     data1.AddRecord(record1);
596     UdmfClient::GetInstance().SetData(option1, data1, key);
597 
598     SetHapToken();
599     Intention intention = UnifiedDataUtils::GetIntentionByString(skey);
600     QueryOption option2 = { .intention = intention };
601     std::vector<UnifiedData> dataSet;
602     UdmfClient::GetInstance().DeleteData(option2, dataSet);
603 }
604 
UpdateDataFuzz(const uint8_t * data,size_t size)605 void UpdateDataFuzz(const uint8_t *data, size_t size)
606 {
607     std::string skey(data, data + size);
608     CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
609     UnifiedData data1;
610     std::string key;
611     PlainText plainText(skey, skey);
612     std::shared_ptr<UnifiedRecord> record1 = std::make_shared<PlainText>(plainText);
613     data1.AddRecord(record1);
614     UdmfClient::GetInstance().SetData(option1, data1, key);
615 
616     SetHapToken();
617     UnifiedData data2;
618     PlainText plainText2(skey + "2", skey + "2");
619     record1 = std::make_shared<PlainText>(plainText2);
620     data2.AddRecord(record1);
621     QueryOption option2 = { .key = key };
622     UdmfClient::GetInstance().UpdateData(option2, data2);
623 
624     SetHapToken();
625     UnifiedData data3;
626     PlainText plainText3(skey + "3", skey + "3");
627     record1 = std::make_shared<PlainText>(plainText3);
628     data3.AddRecord(record1);
629     QueryOption option3 = { .key = skey };
630     UdmfClient::GetInstance().UpdateData(option3, data3);
631 }
632 }
633 
634 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)635 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
636 {
637     /* Run your code on data */
638     OHOS::SetUpTestCase();
639     OHOS::SetDataFileFuzz(data, size);
640     OHOS::SetDataHtmlFuzz(data, size);
641     OHOS::SetDataImageFuzz(data, size);
642     OHOS::SetDataLinkFuzz(data, size);
643     OHOS::SetDataPlainTextFuzz(data, size);
644     OHOS::SetDataSystemDefinedAppItemFuzz(data, size);
645     OHOS::SetDataSystemDefinedFormFuzz(data, size);
646     OHOS::SetDataSystemDefinedPixelMapFuzz(data, size);
647     OHOS::SetDataSystemDefinedRecordFuzz(data, size);
648     OHOS::SetDataTextFuzz(data, size);
649     OHOS::SetDataVideoFuzz(data, size);
650     OHOS::GetSummaryFuzz(data, size);
651     OHOS::GetBatchDataByKeyFuzz(data, size);
652     OHOS::GetBatchDataByIntentionFuzz(data, size);
653     OHOS::DeleteDataByKeyFuzz(data, size);
654     OHOS::DeleteDataByIntentionFuzz(data, size);
655     OHOS::UpdateDataFuzz(data, size);
656     OHOS::TearDown();
657     return 0;
658 }