1
2#include "context_c_fuzzer.h"
3#include "../data.h"
4#include "../../utils/model_utils.h"
5
6bool 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
27bool 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
48bool 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
90bool 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
110bool 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
130bool 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
169bool 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
189bool 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
209bool 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
248bool 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
268bool 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
288bool 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
308bool 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
328bool 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
367bool 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
407bool 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}