• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 
2 #include "context_c_fuzzer.h"
3 #include "fuzztest/data.h"
4 #include "utils/model_utils.h"
5 
6 bool MSContextFuzzTest_ThreadNum(const uint8_t *data, size_t size) {
7     OH_AI_ContextHandle context = OH_AI_ContextCreate();
8     if (context == nullptr) {
9         printf("create context failed.\n");
10         return false;
11     }
12     Data dataFuzz(data, size);
13     int32_t threadNum = dataFuzz.GetData<int32_t>();
14     OH_AI_ContextSetThreadNum(context, threadNum);
15     AddContextDeviceCPU(context);
16     AddContextDeviceNNRT(context);
17 
18     OH_AI_ModelHandle model = OH_AI_ModelCreate();
19     if (model == nullptr) {
20         printf("create model failed.\n");
21         return false;
22     }
23     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
24     return true;
25 }
26 
27 bool MSContextFuzzTest_ThreadAffinityMode(const uint8_t *data, size_t size) {
28     OH_AI_ContextHandle context = OH_AI_ContextCreate();
29     if (context == nullptr) {
30         printf("create context failed.\n");
31         return false;
32     }
33     Data dataFuzz(data, size);
34     int32_t affinityMode = dataFuzz.GetData<int32_t>();
35     OH_AI_ContextSetThreadAffinityMode(context, affinityMode);
36     AddContextDeviceCPU(context);
37     AddContextDeviceNNRT(context);
38 
39     OH_AI_ModelHandle model = OH_AI_ModelCreate();
40     if (model == nullptr) {
41         printf("create model failed.\n");
42         return false;
43     }
44     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
45     return true;
46 }
47 
48 bool MSContextFuzzTest_Provider(const uint8_t *data, size_t size) {
49     OH_AI_ContextHandle context = OH_AI_ContextCreate();
50     if (context == nullptr) {
51         printf("create context failed.\n");
52         return false;
53     }
54     char *infoProvider = static_cast<char *>(malloc(size + 1));
55     if (infoProvider == nullptr) {
56         printf("malloc failed.\n");
57         return false;
58     }
59     if (memcpy_s(infoProvider, size + 1, data, size) != EOK) {
60         printf("memcpy_s failed.");
61         free(infoProvider);
62         return false;
63     }
64     infoProvider[size] = '\0';
65     OH_AI_DeviceInfoHandle cpuDeviceInfo = OH_AI_DeviceInfoCreate(OH_AI_DEVICETYPE_CPU);
66     if (cpuDeviceInfo == nullptr) {
67         printf("OH_AI_DeviceInfoCreate failed.\n");
68         OH_AI_ContextDestroy(&context);
69         free(infoProvider);
70         return OH_AI_STATUS_LITE_ERROR;
71     }
72     OH_AI_DeviceInfoSetProvider(cpuDeviceInfo, infoProvider);
73     OH_AI_DeviceInfoSetProviderDevice(cpuDeviceInfo, infoProvider);
74     OH_AI_ContextAddDeviceInfo(context, cpuDeviceInfo);
75 
76     AddContextDeviceNNRT(context);
77 
78     OH_AI_ModelHandle model = OH_AI_ModelCreate();
79     if (model == nullptr) {
80         printf("create model failed.\n");
81         free(infoProvider);
82         return false;
83     }
84     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
85     free(infoProvider);
86     return true;
87 }
88 
89 
90 bool MSContextFuzzTest_ThreadNum_Add1(const uint8_t *data, size_t size) {
91     OH_AI_ContextHandle context = OH_AI_ContextCreate();
92     if (context == nullptr) {
93         printf("create context failed.\n");
94         return false;
95     }
96     Data dataFuzz(data, size);
97     int32_t threadNum = dataFuzz.GetData<int32_t>();
98     OH_AI_ContextSetThreadNum(context, threadNum);
99     AddContextDeviceCPU(context);
100 
101     OH_AI_ModelHandle model = OH_AI_ModelCreate();
102     if (model == nullptr) {
103         printf("create model failed.\n");
104         return false;
105     }
106     ModelPredict(model, context, "ml_face_isface", {}, true, true, false);
107     return true;
108 }
109 
110 bool MSContextFuzzTest_ThreadAffinityMode_Add1(const uint8_t *data, size_t size) {
111     OH_AI_ContextHandle context = OH_AI_ContextCreate();
112     if (context == nullptr) {
113         printf("create context failed.\n");
114         return false;
115     }
116     Data dataFuzz(data, size);
117     int32_t affinityMode = dataFuzz.GetData<int32_t>();
118     OH_AI_ContextSetThreadAffinityMode(context, affinityMode);
119     AddContextDeviceCPU(context);
120 
121     OH_AI_ModelHandle model = OH_AI_ModelCreate();
122     if (model == nullptr) {
123         printf("create model failed.\n");
124         return false;
125     }
126     ModelPredict(model, context, "ml_face_isface", {}, true, true, false);
127     return true;
128 }
129 
130 bool MSContextFuzzTest_Provider_Add1(const uint8_t *data, size_t size) {
131     OH_AI_ContextHandle context = OH_AI_ContextCreate();
132     if (context == nullptr) {
133         printf("create context failed.\n");
134         return false;
135     }
136     char *infoProvider = static_cast<char *>(malloc(size + 1));
137     if (infoProvider == nullptr) {
138         printf("malloc failed.\n");
139         return false;
140     }
141     if (memcpy_s(infoProvider, size + 1, data, size) != EOK) {
142         printf("memcpy_s failed.");
143         free(infoProvider);
144         return false;
145     }
146     infoProvider[size] = '\0';
147     OH_AI_DeviceInfoHandle cpuDeviceInfo = OH_AI_DeviceInfoCreate(OH_AI_DEVICETYPE_CPU);
148     if (cpuDeviceInfo == nullptr) {
149         printf("OH_AI_DeviceInfoCreate failed.\n");
150         OH_AI_ContextDestroy(&context);
151         free(infoProvider);
152         return OH_AI_STATUS_LITE_ERROR;
153     }
154     OH_AI_DeviceInfoSetProvider(cpuDeviceInfo, infoProvider);
155     OH_AI_DeviceInfoSetProviderDevice(cpuDeviceInfo, infoProvider);
156     OH_AI_ContextAddDeviceInfo(context, cpuDeviceInfo);
157 
158     OH_AI_ModelHandle model = OH_AI_ModelCreate();
159     if (model == nullptr) {
160         printf("create model failed.\n");
161         free(infoProvider);
162         return false;
163     }
164     ModelPredict(model, context, "ml_face_isface", {}, true, true, false);
165     free(infoProvider);
166     return true;
167 }
168 
169 bool MSContextFuzzTest_ThreadNum_Add2(const uint8_t *data, size_t size) {
170     OH_AI_ContextHandle context = OH_AI_ContextCreate();
171     if (context == nullptr) {
172         printf("create context failed.\n");
173         return false;
174     }
175     Data dataFuzz(data, size);
176     int32_t threadNum = dataFuzz.GetData<int32_t>();
177     OH_AI_ContextSetThreadNum(context, threadNum);
178     AddContextDeviceCPU(context);
179 
180     OH_AI_ModelHandle model = OH_AI_ModelCreate();
181     if (model == nullptr) {
182         printf("create model failed.\n");
183         return false;
184     }
185     ModelPredict(model, context, "ml_face_isface", {}, false, true, true);
186     return true;
187 }
188 
189 bool MSContextFuzzTest_ThreadAffinityMode_Add2(const uint8_t *data, size_t size) {
190     OH_AI_ContextHandle context = OH_AI_ContextCreate();
191     if (context == nullptr) {
192         printf("create context failed.\n");
193         return false;
194     }
195     Data dataFuzz(data, size);
196     int32_t affinityMode = dataFuzz.GetData<int32_t>();
197     OH_AI_ContextSetThreadAffinityMode(context, affinityMode);
198     AddContextDeviceCPU(context);
199 
200     OH_AI_ModelHandle model = OH_AI_ModelCreate();
201     if (model == nullptr) {
202         printf("create model failed.\n");
203         return false;
204     }
205     ModelPredict(model, context, "ml_face_isface", {}, false, true, true);
206     return true;
207 }
208 
209 bool MSContextFuzzTest_Provider_Add2(const uint8_t *data, size_t size) {
210     OH_AI_ContextHandle context = OH_AI_ContextCreate();
211     if (context == nullptr) {
212         printf("create context failed.\n");
213         return false;
214     }
215     char *infoProvider = static_cast<char *>(malloc(size + 1));
216     if (infoProvider == nullptr) {
217         printf("malloc failed.\n");
218         return false;
219     }
220     if (memcpy_s(infoProvider, size + 1, data, size) != EOK) {
221         printf("memcpy_s failed.");
222         free(infoProvider);
223         return false;
224     }
225     infoProvider[size] = '\0';
226     OH_AI_DeviceInfoHandle cpuDeviceInfo = OH_AI_DeviceInfoCreate(OH_AI_DEVICETYPE_CPU);
227     if (cpuDeviceInfo == nullptr) {
228         printf("OH_AI_DeviceInfoCreate failed.\n");
229         OH_AI_ContextDestroy(&context);
230         free(infoProvider);
231         return OH_AI_STATUS_LITE_ERROR;
232     }
233     OH_AI_DeviceInfoSetProvider(cpuDeviceInfo, infoProvider);
234     OH_AI_DeviceInfoSetProviderDevice(cpuDeviceInfo, infoProvider);
235     OH_AI_ContextAddDeviceInfo(context, cpuDeviceInfo);
236 
237     OH_AI_ModelHandle model = OH_AI_ModelCreate();
238     if (model == nullptr) {
239         printf("create model failed.\n");
240         free(infoProvider);
241         return false;
242     }
243     ModelPredict(model, context, "ml_face_isface", {}, false, true, true);
244     free(infoProvider);
245     return true;
246 }
247 
248 bool MSContextFuzzTest_ThreadNum_Add3(const uint8_t *data, size_t size) {
249     OH_AI_ContextHandle context = OH_AI_ContextCreate();
250     if (context == nullptr) {
251         printf("create context failed.\n");
252         return false;
253     }
254     Data dataFuzz(data, size);
255     int32_t threadNum = dataFuzz.GetData<int32_t>();
256     OH_AI_ContextSetThreadNum(context, threadNum);
257     AddContextDeviceCPU(context);
258 
259     OH_AI_ModelHandle model = OH_AI_ModelCreate();
260     if (model == nullptr) {
261         printf("create model failed.\n");
262         return false;
263     }
264     ModelPredict_ModelBuild(model, context, "ml_face_isface", true);
265     return true;
266 }
267 
268 bool MSContextFuzzTest_ThreadNum_Add4(const uint8_t *data, size_t size) {
269     OH_AI_ContextHandle context = OH_AI_ContextCreate();
270     if (context == nullptr) {
271         printf("create context failed.\n");
272         return false;
273     }
274     Data dataFuzz(data, size);
275     int32_t threadNum = dataFuzz.GetData<int32_t>();
276     OH_AI_ContextSetThreadNum(context, threadNum);
277     AddContextDeviceCPU(context);
278 
279     OH_AI_ModelHandle model = OH_AI_ModelCreate();
280     if (model == nullptr) {
281         printf("create model failed.\n");
282         return false;
283     }
284     ModelPredict_ModelBuild(model, context, "ml_face_isface", false);
285     return true;
286 }
287 
288 bool MSContextFuzzTest_ThreadAffinityMode_Add3(const uint8_t *data, size_t size) {
289     OH_AI_ContextHandle context = OH_AI_ContextCreate();
290     if (context == nullptr) {
291         printf("create context failed.\n");
292         return false;
293     }
294     Data dataFuzz(data, size);
295     int32_t affinityMode = dataFuzz.GetData<int32_t>();
296     OH_AI_ContextSetThreadAffinityMode(context, affinityMode);
297     AddContextDeviceCPU(context);
298 
299     OH_AI_ModelHandle model = OH_AI_ModelCreate();
300     if (model == nullptr) {
301         printf("create model failed.\n");
302         return false;
303     }
304     ModelPredict_ModelBuild(model, context, "ml_face_isface", true);
305     return true;
306 }
307 
308 bool MSContextFuzzTest_ThreadAffinityMode_Add4(const uint8_t *data, size_t size) {
309     OH_AI_ContextHandle context = OH_AI_ContextCreate();
310     if (context == nullptr) {
311         printf("create context failed.\n");
312         return false;
313     }
314     Data dataFuzz(data, size);
315     int32_t affinityMode = dataFuzz.GetData<int32_t>();
316     OH_AI_ContextSetThreadAffinityMode(context, affinityMode);
317     AddContextDeviceCPU(context);
318 
319     OH_AI_ModelHandle model = OH_AI_ModelCreate();
320     if (model == nullptr) {
321         printf("create model failed.\n");
322         return false;
323     }
324     ModelPredict_ModelBuild(model, context, "ml_face_isface", false);
325     return true;
326 }
327 
328 bool MSContextFuzzTest_Provider_Add3(const uint8_t* data, size_t size) {
329     OH_AI_ContextHandle context = OH_AI_ContextCreate();
330     if (context == nullptr) {
331         printf("create context failed.\n");
332         return false;
333     }
334     char *infoProvider = static_cast<char *>(malloc(size + 1));
335     if (infoProvider == nullptr) {
336         printf("malloc failed.\n");
337         return false;
338     }
339     if (memcpy_s(infoProvider, size + 1, data, size) != EOK) {
340         printf("memcpy_s failed.");
341         free(infoProvider);
342         return false;
343     }
344     infoProvider[size] = '\0';
345     OH_AI_DeviceInfoHandle cpuDeviceInfo = OH_AI_DeviceInfoCreate(OH_AI_DEVICETYPE_CPU);
346     if (cpuDeviceInfo == nullptr) {
347         printf("OH_AI_DeviceInfoCreate failed.\n");
348         OH_AI_ContextDestroy(&context);
349         free(infoProvider);
350         return OH_AI_STATUS_LITE_ERROR;
351     }
352     OH_AI_DeviceInfoSetProvider(cpuDeviceInfo, infoProvider);
353     OH_AI_DeviceInfoSetProviderDevice(cpuDeviceInfo, infoProvider);
354     OH_AI_ContextAddDeviceInfo(context, cpuDeviceInfo);
355 
356     OH_AI_ModelHandle model = OH_AI_ModelCreate();
357     if (model == nullptr) {
358         printf("create model failed.\n");
359         free(infoProvider);
360         return false;
361     }
362     ModelPredict_ModelBuild(model, context, "ml_face_isface", true);
363     free(infoProvider);
364     return true;
365 }
366 
367 bool MSContextFuzzTest_Provider_Add4(const uint8_t *data, size_t size) {
368     OH_AI_ContextHandle context = OH_AI_ContextCreate();
369     if (context == nullptr) {
370         printf("create context failed.\n");
371         return false;
372     }
373     char *infoProvider = static_cast<char *>(malloc(size + 1));
374     if (infoProvider == nullptr) {
375         printf("malloc failed.\n");
376         return false;
377     }
378     if (memcpy_s(infoProvider, size + 1, data, size) != EOK) {
379         printf("memcpy_s failed.");
380         free(infoProvider);
381         return false;
382     }
383     infoProvider[size] = '\0';
384     OH_AI_DeviceInfoHandle cpuDeviceInfo = OH_AI_DeviceInfoCreate(OH_AI_DEVICETYPE_CPU);
385     if (cpuDeviceInfo == nullptr) {
386         printf("OH_AI_DeviceInfoCreate failed.\n");
387         OH_AI_ContextDestroy(&context);
388         free(infoProvider);
389         return OH_AI_STATUS_LITE_ERROR;
390     }
391     OH_AI_DeviceInfoSetProvider(cpuDeviceInfo, infoProvider);
392     OH_AI_DeviceInfoSetProviderDevice(cpuDeviceInfo, infoProvider);
393     OH_AI_ContextAddDeviceInfo(context, cpuDeviceInfo);
394 
395     OH_AI_ModelHandle model = OH_AI_ModelCreate();
396     if (model == nullptr) {
397         printf("create model failed.\n");
398         free(infoProvider);
399         return false;
400     }
401     ModelPredict_ModelBuild(model, context, "ml_face_isface", false);
402     free(infoProvider);
403     return true;
404 }
405 
406 
407 bool MSContextFuzzTest(const uint8_t *data, size_t size) {
408     bool ret = MSContextFuzzTest_ThreadNum(data, size) && MSContextFuzzTest_ThreadNum_Add1(data, size) &&
409                MSContextFuzzTest_ThreadNum_Add2(data, size) && MSContextFuzzTest_ThreadNum_Add3(data, size) &&
410                MSContextFuzzTest_ThreadNum_Add4(data, size) && MSContextFuzzTest_ThreadAffinityMode(data, size) &&
411                MSContextFuzzTest_ThreadAffinityMode_Add1(data, size) &&
412                MSContextFuzzTest_ThreadAffinityMode_Add2(data, size) &&
413                MSContextFuzzTest_ThreadAffinityMode_Add3(data, size) &&
414                MSContextFuzzTest_ThreadAffinityMode_Add4(data, size) && MSContextFuzzTest_Provider(data, size) &&
415                MSContextFuzzTest_Provider_Add1(data, size) && MSContextFuzzTest_Provider_Add2(data, size) &&
416                MSContextFuzzTest_Provider_Add3(data, size) && MSContextFuzzTest_Provider_Add4(data, size);
417     return ret;
418 }