• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022 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 <thread>
17 #include <inttypes.h>
18 #include <securec.h>
19 #include "ohos_common.h"
20 #include "gtest/gtest.h"
21 #include "include/c_api/context_c.h"
22 #include "include/c_api/model_c.h"
23 #include "include/c_api/types_c.h"
24 #include "include/c_api/status_c.h"
25 #include "include/c_api/data_type_c.h"
26 #include "include/c_api/tensor_c.h"
27 #include "include/c_api/format_c.h"
28 
29 using namespace testing::ext;
30 
31 class MSLiteTest: public testing::Test {
32 protected:
SetUpTestCase(void)33   static void SetUpTestCase(void) {}
TearDownTestCase(void)34   static void TearDownTestCase(void) {}
SetUp()35   virtual void SetUp() {}
TearDown()36   virtual void TearDown() {}
37 };
38 
39 // function before callback
PrintBeforeCallback(const OH_AI_TensorHandleArray inputs,const OH_AI_TensorHandleArray outputs,const OH_AI_CallBackParam kernel_Info)40 bool PrintBeforeCallback(const OH_AI_TensorHandleArray inputs, const OH_AI_TensorHandleArray outputs,
41                          const OH_AI_CallBackParam kernel_Info) {
42     std::cout << "Before forwarding " << kernel_Info.node_name << " " << kernel_Info.node_type << std::endl;
43     return true;
44 }
45 
46 // function after callback
PrintAfterCallback(const OH_AI_TensorHandleArray inputs,const OH_AI_TensorHandleArray outputs,const OH_AI_CallBackParam kernel_Info)47 bool PrintAfterCallback(const OH_AI_TensorHandleArray inputs, const OH_AI_TensorHandleArray outputs,
48                         const OH_AI_CallBackParam kernel_Info) {
49     std::cout << "After forwarding " << kernel_Info.node_name << " " << kernel_Info.node_type << std::endl;
50     return true;
51 }
52 
53 // add cpu device info
AddContextDeviceCPU(OH_AI_ContextHandle context)54 void AddContextDeviceCPU(OH_AI_ContextHandle context) {
55     OH_AI_DeviceInfoHandle cpu_device_info = OH_AI_DeviceInfoCreate(OH_AI_DEVICETYPE_CPU);
56     ASSERT_NE(cpu_device_info, nullptr);
57     OH_AI_DeviceType device_type = OH_AI_DeviceInfoGetDeviceType(cpu_device_info);
58     printf("==========device_type:%d\n", device_type);
59     ASSERT_EQ(device_type, OH_AI_DEVICETYPE_CPU);
60     OH_AI_ContextAddDeviceInfo(context, cpu_device_info);
61 }
62 
63 // fill data to inputs tensor
FillInputsData(OH_AI_TensorHandleArray inputs,string model_name,bool is_transpose)64 void FillInputsData(OH_AI_TensorHandleArray inputs, string model_name, bool is_transpose) {
65     for (size_t i = 0; i < inputs.handle_num; ++i) {
66         printf("==========ReadFile==========\n");
67         size_t size1;
68         size_t *ptr_size1 = &size1;
69         string input_data_path = "/data/test/" + model_name + "_" + std::to_string(i) + ".input";
70         const char *imagePath = input_data_path.c_str();
71         char *imageBuf = ReadFile(imagePath, ptr_size1);
72         ASSERT_NE(imageBuf, nullptr);
73         OH_AI_TensorHandle tensor = inputs.handle_list[i];
74         int64_t element_num = OH_AI_TensorGetElementNum(tensor);
75         printf("Tensor name: %s. \n", OH_AI_TensorGetName(tensor));
76         float *input_data = reinterpret_cast<float *>(OH_AI_TensorGetMutableData(inputs.handle_list[i]));
77         ASSERT_NE(input_data, nullptr);
78         if (is_transpose) {
79             printf("==========Transpose==========\n");
80             size_t shape_num;
81             const int64_t *shape = OH_AI_TensorGetShape(tensor, &shape_num);
82             auto imageBuf_nhwc = new char[size1];
83             PackNCHWToNHWCFp32(imageBuf, imageBuf_nhwc, shape[0], shape[1] * shape[2], shape[3]);
84             memcpy_s(input_data, size1, imageBuf_nhwc, size1);
85         } else {
86             memcpy_s(input_data, size1, imageBuf, size1);
87         }
88         printf("input data after filling is: ");
89         for (int j = 0; j < element_num && j <= 20; ++j) {
90             printf("%f ", input_data[j]);
91         }
92         printf("\n");
93         delete[] imageBuf;
94     }
95 }
96 
97 // compare result after predict
CompareResult(OH_AI_TensorHandleArray outputs,string model_name)98 void CompareResult(OH_AI_TensorHandleArray outputs, string model_name) {
99     printf("==========GetOutput==========\n");
100     for (size_t i = 0; i < outputs.handle_num; ++i) {
101         OH_AI_TensorHandle tensor = outputs.handle_list[i];
102         int64_t element_num = OH_AI_TensorGetElementNum(tensor);
103         printf("Tensor name: %s .\n", OH_AI_TensorGetName(tensor));
104         float *output_data = reinterpret_cast<float *>(OH_AI_TensorGetMutableData(tensor));
105         printf("output data is:");
106         for (int j = 0; j < element_num && j <= 20; ++j) {
107             printf("%f ", output_data[j]);
108         }
109         printf("\n");
110         printf("==========compFp32WithTData==========\n");
111         string output_file = "/data/test/" + model_name + std::to_string(i) + ".output";
112         bool result = compFp32WithTData(output_data, output_file, 0.01, 0.01, false);
113         EXPECT_EQ(result, true);
114     }
115 }
116 
117 // model build and predict
ModelPredict(OH_AI_ModelHandle model,OH_AI_ContextHandle context,string model_name,OH_AI_ShapeInfo shape_infos,bool build_by_graph,bool is_transpose,bool is_callback)118 void ModelPredict(OH_AI_ModelHandle model, OH_AI_ContextHandle context, string model_name,
119             OH_AI_ShapeInfo shape_infos, bool build_by_graph, bool is_transpose, bool is_callback) {
120     string model_path = "/data/test/" + model_name + ".ms";
121     const char *graphPath = model_path.c_str();
122     OH_AI_Status ret = OH_AI_STATUS_SUCCESS;
123     if (build_by_graph) {
124         printf("==========Build model by graphBuf==========\n");
125         size_t size;
126         size_t *ptr_size = &size;
127         char *graphBuf = ReadFile(graphPath, ptr_size);
128         ASSERT_NE(graphBuf, nullptr);
129         ret = OH_AI_ModelBuild(model, graphBuf, size, OH_AI_MODELTYPE_MINDIR, context);
130     } else {
131         printf("==========Build model==========\n");
132         ret = OH_AI_ModelBuildFromFile(model, graphPath, OH_AI_MODELTYPE_MINDIR, context);
133     }
134     printf("==========build model return code:%d\n", ret);
135     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
136     printf("==========GetInputs==========\n");
137     OH_AI_TensorHandleArray inputs = OH_AI_ModelGetInputs(model);
138     ASSERT_NE(inputs.handle_list, nullptr);
139     if (shape_infos.shape_num != NULL) {
140         printf("==========Resizes==========\n");
141         OH_AI_Status resize_ret = OH_AI_ModelResize(model, inputs, &shape_infos, inputs.handle_num);
142         printf("==========Resizes return code:%d\n", resize_ret);
143         ASSERT_EQ(resize_ret, OH_AI_STATUS_SUCCESS);
144     }
145     FillInputsData(inputs, model_name, is_transpose);
146     OH_AI_TensorHandleArray outputs;
147     OH_AI_Status predict_ret = OH_AI_STATUS_SUCCESS;
148     if (is_callback) {
149         printf("==========Model Predict Callback==========\n");
150         OH_AI_KernelCallBack before_call_back = PrintBeforeCallback;
151         OH_AI_KernelCallBack after_call_back = PrintAfterCallback;
152         predict_ret = OH_AI_ModelPredict(model, inputs, &outputs, before_call_back, after_call_back);
153     }else {
154         printf("==========Model Predict==========\n");
155         predict_ret = OH_AI_ModelPredict(model, inputs, &outputs, nullptr, nullptr);
156     }
157     ASSERT_EQ(predict_ret, OH_AI_STATUS_SUCCESS);
158     CompareResult(outputs, model_name);
159     OH_AI_ModelDestroy(&model);
160 }
161 
162 // predict on cpu
Predict_CPU()163 void Predict_CPU() {
164     printf("==========Init Context==========\n");
165     OH_AI_ContextHandle context = OH_AI_ContextCreate();
166     ASSERT_NE(context, nullptr);
167     AddContextDeviceCPU(context);
168     printf("==========Create model==========\n");
169     OH_AI_ModelHandle model = OH_AI_ModelCreate();
170     ASSERT_NE(model, nullptr);
171     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
172 }
173 
174 // 正常场景：Context设置CPU，默认场景，不设置线程绑核
175 HWTEST(MSLiteTest, OHOS_Context_CPU_0001, Function | MediumTest | Level1) {
176     printf("==========Init Context==========\n");
177     OH_AI_ContextHandle context = OH_AI_ContextCreate();
178     ASSERT_NE(context, nullptr);
179     AddContextDeviceCPU(context);
180     printf("==========Create model==========\n");
181     OH_AI_ModelHandle model = OH_AI_ModelCreate();
182     ASSERT_NE(model, nullptr);
183     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
184 }
185 
186 // 正常场景：Context设置CPU，4线程
187 HWTEST(MSLiteTest, OHOS_Context_CPU_0002, Function | MediumTest | Level1) {
188     printf("==========Init Context==========\n");
189     OH_AI_ContextHandle context = OH_AI_ContextCreate();
190     ASSERT_NE(context, nullptr);
191     OH_AI_ContextSetThreadNum(context, 4);
192     int32_t thread_num = OH_AI_ContextGetThreadNum(context);
193     printf("==========thread_num:%d\n", thread_num);
194     ASSERT_EQ(thread_num, 4);
195     AddContextDeviceCPU(context);
196     printf("==========Create model==========\n");
197     OH_AI_ModelHandle model = OH_AI_ModelCreate();
198     ASSERT_NE(model, nullptr);
199     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
200 }
201 
202 // 正常场景：Context设置CPU，2线程
203 HWTEST(MSLiteTest, OHOS_Context_CPU_0003, Function | MediumTest | Level1) {
204     printf("==========Init Context==========\n");
205     OH_AI_ContextHandle context = OH_AI_ContextCreate();
206     ASSERT_NE(context, nullptr);
207     OH_AI_ContextSetThreadNum(context, 2);
208     int32_t thread_num = OH_AI_ContextGetThreadNum(context);
209     printf("==========thread_num:%d\n", thread_num);
210     ASSERT_EQ(thread_num, 2);
211     AddContextDeviceCPU(context);
212     printf("==========Create model==========\n");
213     OH_AI_ModelHandle model = OH_AI_ModelCreate();
214     ASSERT_NE(model, nullptr);
215     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
216 }
217 
218 // 正常场景：Context设置CPU，1线程
219 HWTEST(MSLiteTest, OHOS_Context_CPU_0004, Function | MediumTest | Level1) {
220     printf("==========Init Context==========\n");
221     OH_AI_ContextHandle context = OH_AI_ContextCreate();
222     ASSERT_NE(context, nullptr);
223     OH_AI_ContextSetThreadNum(context, 1);
224     int32_t thread_num = OH_AI_ContextGetThreadNum(context);
225     printf("==========thread_num:%d\n", thread_num);
226     ASSERT_EQ(thread_num, 1);
227     AddContextDeviceCPU(context);
228     printf("==========Create model==========\n");
229     OH_AI_ModelHandle model = OH_AI_ModelCreate();
230     ASSERT_NE(model, nullptr);
231     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
232 }
233 
234 // 异常场景：Context设置CPU，0线程
235 HWTEST(MSLiteTest, OHOS_Context_CPU_0005, Function | MediumTest | Level1) {
236     printf("==========Init Context==========\n");
237     OH_AI_ContextHandle context = OH_AI_ContextCreate();
238     ASSERT_NE(context, nullptr);
239     OH_AI_ContextSetThreadNum(context, 0);
240     int32_t thread_num = OH_AI_ContextGetThreadNum(context);
241     printf("==========thread_num:%d\n", thread_num);
242     ASSERT_EQ(thread_num, 0);
243     AddContextDeviceCPU(context);
244     printf("==========Create model==========\n");
245     OH_AI_ModelHandle model = OH_AI_ModelCreate();
246     ASSERT_NE(model, nullptr);
247     printf("==========Build model==========\n");
248     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_face_isface.ms", OH_AI_MODELTYPE_MINDIR, context);
249     printf("==========build model return code:%d\n", ret);
250     ASSERT_EQ(ret, OH_AI_STATUS_LITE_NOT_SUPPORT);
251     OH_AI_ModelDestroy(&model);
252 }
253 
254 // 正常场景：Context设置CPU，不绑核
255 HWTEST(MSLiteTest, OHOS_Context_CPU_0006, Function | MediumTest | Level1) {
256     printf("==========Init Context==========\n");
257     OH_AI_ContextHandle context = OH_AI_ContextCreate();
258     ASSERT_NE(context, nullptr);
259     OH_AI_ContextSetThreadNum(context, 4);
260     int32_t thread_num = OH_AI_ContextGetThreadNum(context);
261     printf("==========thread_num:%d\n", thread_num);
262     ASSERT_EQ(thread_num, 4);
263     OH_AI_ContextSetThreadAffinityMode(context, 0);
264     int thread_affinity_mode = OH_AI_ContextGetThreadAffinityMode(context);
265     printf("==========thread_affinity_mode:%d\n", thread_affinity_mode);
266     ASSERT_EQ(thread_affinity_mode, 0);
267     AddContextDeviceCPU(context);
268     printf("==========Create model==========\n");
269     OH_AI_ModelHandle model = OH_AI_ModelCreate();
270     ASSERT_NE(model, nullptr);
271     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
272 }
273 
274 // 正常场景：Context设置CPU，绑大核
275 HWTEST(MSLiteTest, OHOS_Context_CPU_0007, Function | MediumTest | Level1) {
276     printf("==========Init Context==========\n");
277     OH_AI_ContextHandle context = OH_AI_ContextCreate();
278     ASSERT_NE(context, nullptr);
279     OH_AI_ContextSetThreadNum(context, 4);
280     int32_t thread_num = OH_AI_ContextGetThreadNum(context);
281     printf("==========thread_num:%d\n", thread_num);
282     ASSERT_EQ(thread_num, 4);
283     OH_AI_ContextSetThreadAffinityMode(context, 1);
284     int thread_affinity_mode = OH_AI_ContextGetThreadAffinityMode(context);
285     printf("==========thread_affinity_mode:%d\n", thread_affinity_mode);
286     ASSERT_EQ(thread_affinity_mode, 1);
287     AddContextDeviceCPU(context);
288     printf("==========Create model==========\n");
289     OH_AI_ModelHandle model = OH_AI_ModelCreate();
290     ASSERT_NE(model, nullptr);
291     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
292 }
293 
294 // 正常场景：Context设置CPU，绑中核
295 HWTEST(MSLiteTest, OHOS_Context_CPU_0008, Function | MediumTest | Level1) {
296     printf("==========Init Context==========\n");
297     OH_AI_ContextHandle context = OH_AI_ContextCreate();
298     ASSERT_NE(context, nullptr);
299     OH_AI_ContextSetThreadNum(context, 4);
300     int32_t thread_num = OH_AI_ContextGetThreadNum(context);
301     printf("==========thread_num:%d\n", thread_num);
302     ASSERT_EQ(thread_num, 4);
303     OH_AI_ContextSetThreadAffinityMode(context, 2);
304     int thread_affinity_mode = OH_AI_ContextGetThreadAffinityMode(context);
305     printf("==========thread_affinity_mode:%d\n", thread_affinity_mode);
306     ASSERT_EQ(thread_affinity_mode, 2);
307     AddContextDeviceCPU(context);
308     printf("==========Create model==========\n");
309     OH_AI_ModelHandle model = OH_AI_ModelCreate();
310     ASSERT_NE(model, nullptr);
311     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
312 }
313 
314 // 异常场景：Context设置CPU，绑核失败
315 HWTEST(MSLiteTest, OHOS_Context_CPU_0009, Function | MediumTest | Level1) {
316     printf("==========Init Context==========\n");
317     OH_AI_ContextHandle context = OH_AI_ContextCreate();
318     ASSERT_NE(context, nullptr);
319     OH_AI_ContextSetThreadNum(context, 4);
320     int32_t thread_num = OH_AI_ContextGetThreadNum(context);
321     printf("==========thread_num:%d\n", thread_num);
322     ASSERT_EQ(thread_num, 4);
323     OH_AI_ContextSetThreadAffinityMode(context, 3);
324     int thread_affinity_mode = OH_AI_ContextGetThreadAffinityMode(context);
325     printf("==========thread_affinity_mode:%d\n", thread_affinity_mode);
326     ASSERT_EQ(thread_affinity_mode, 3);
327     AddContextDeviceCPU(context);
328     printf("==========Create model==========\n");
329     OH_AI_ModelHandle model = OH_AI_ModelCreate();
330     ASSERT_NE(model, nullptr);
331     printf("==========Build model==========\n");
332     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_face_isface.ms", OH_AI_MODELTYPE_MINDIR, context);
333     printf("==========build model return code:%d\n", ret);
334     ASSERT_EQ(ret, OH_AI_STATUS_LITE_NULLPTR);
335     OH_AI_ModelDestroy(&model);
336 }
337 
338 // 正常场景：Context设置CPU，绑核列表{0,1,2,3}
339 HWTEST(MSLiteTest, OHOS_Context_CPU_0010, Function | MediumTest | Level1) {
340     printf("==========Init Context==========\n");
341     OH_AI_ContextHandle context = OH_AI_ContextCreate();
342     ASSERT_NE(context, nullptr);
343     OH_AI_ContextSetThreadNum(context, 4);
344     int32_t thread_num = OH_AI_ContextGetThreadNum(context);
345     printf("==========thread_num:%d\n", thread_num);
346     ASSERT_EQ(thread_num, 4);
347     constexpr size_t core_num = 4;
348     int32_t core_list[core_num] = {0, 1, 2, 3};
349     OH_AI_ContextSetThreadAffinityCoreList(context, core_list, core_num);
350     size_t ret_core_num;
351     const int32_t *ret_core_list = nullptr;
352     ret_core_list = OH_AI_ContextGetThreadAffinityCoreList(context, &ret_core_num);
353     ASSERT_EQ(ret_core_num, core_num);
354     for (size_t i = 0; i < ret_core_num; i++) {
355         printf("==========ret_core_list:%d\n", ret_core_list[i]);
356         ASSERT_EQ(ret_core_list[i], core_list[i]);
357     }
358     AddContextDeviceCPU(context);
359     printf("==========Create model==========\n");
360     OH_AI_ModelHandle model = OH_AI_ModelCreate();
361     ASSERT_NE(model, nullptr);
362     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
363 }
364 
365 // 正常场景：Context设置CPU，绑核列表和模式同时开启
366 HWTEST(MSLiteTest, OHOS_Context_CPU_0011, Function | MediumTest | Level1) {
367     printf("==========Init Context==========\n");
368     OH_AI_ContextHandle context = OH_AI_ContextCreate();
369     ASSERT_NE(context, nullptr);
370     OH_AI_ContextSetThreadNum(context, 4);
371     int32_t thread_num = OH_AI_ContextGetThreadNum(context);
372     printf("==========thread_num:%d\n", thread_num);
373     ASSERT_EQ(thread_num, 4);
374     OH_AI_ContextSetThreadAffinityMode(context, 1);
375     int thread_affinity_mode = OH_AI_ContextGetThreadAffinityMode(context);
376     printf("==========thread_affinity_mode:%d\n", thread_affinity_mode);
377     constexpr size_t core_num = 4;
378     int32_t core_list[core_num] = {0, 1, 3, 4};
379     OH_AI_ContextSetThreadAffinityCoreList(context, core_list, core_num);
380     size_t ret_core_num;
381     const int32_t *ret_core_list = nullptr;
382     ret_core_list = OH_AI_ContextGetThreadAffinityCoreList(context, &ret_core_num);
383     ASSERT_EQ(ret_core_num, core_num);
384     for (size_t i = 0; i < ret_core_num; i++) {
385         printf("==========ret_core_list:%d\n", ret_core_list[i]);
386         ASSERT_EQ(ret_core_list[i], core_list[i]);
387     }
388     AddContextDeviceCPU(context);
389     printf("==========Create model==========\n");
390     OH_AI_ModelHandle model = OH_AI_ModelCreate();
391     ASSERT_NE(model, nullptr);
392     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
393 }
394 
395 // 正常场景：Context设置CPU，开启并行
396 HWTEST(MSLiteTest, OHOS_Context_CPU_0012, Function | MediumTest | Level1) {
397     printf("==========Init Context==========\n");
398     OH_AI_ContextHandle context = OH_AI_ContextCreate();
399     ASSERT_NE(context, nullptr);
400     OH_AI_ContextSetThreadNum(context, 4);
401     int32_t thread_num = OH_AI_ContextGetThreadNum(context);
402     printf("==========thread_num:%d\n", thread_num);
403     ASSERT_EQ(thread_num, 4);
404     OH_AI_ContextSetEnableParallel(context, true);
405     bool is_parallel = OH_AI_ContextGetEnableParallel(context);
406     printf("==========is_parallel:%d\n", is_parallel);
407     ASSERT_EQ(is_parallel, true);
408     AddContextDeviceCPU(context);
409     printf("==========Create model==========\n");
410     OH_AI_ModelHandle model = OH_AI_ModelCreate();
411     ASSERT_NE(model, nullptr);
412     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
413 }
414 
415 // 正常场景：Context设置CPU，关闭并行
416 HWTEST(MSLiteTest, OHOS_Context_CPU_0013, Function | MediumTest | Level1) {
417     printf("==========Init Context==========\n");
418     OH_AI_ContextHandle context = OH_AI_ContextCreate();
419     ASSERT_NE(context, nullptr);
420     OH_AI_ContextSetThreadNum(context, 4);
421     int32_t thread_num = OH_AI_ContextGetThreadNum(context);
422     printf("==========thread_num:%d\n", thread_num);
423     ASSERT_EQ(thread_num, 4);
424     OH_AI_ContextSetEnableParallel(context, false);
425     bool is_parallel = OH_AI_ContextGetEnableParallel(context);
426     printf("==========is_parallel:%d\n", is_parallel);
427     ASSERT_EQ(is_parallel, false);
428     AddContextDeviceCPU(context);
429     printf("==========Create model==========\n");
430     OH_AI_ModelHandle model = OH_AI_ModelCreate();
431     ASSERT_NE(model, nullptr);
432     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
433 }
434 
435 // 正常场景：Context设置CPU，开启fp16
436 HWTEST(MSLiteTest, OHOS_Context_CPU_0014, Function | MediumTest | Level1) {
437     printf("==========Init Context==========\n");
438     OH_AI_ContextHandle context = OH_AI_ContextCreate();
439     ASSERT_NE(context, nullptr);
440     OH_AI_DeviceInfoHandle cpu_device_info = OH_AI_DeviceInfoCreate(OH_AI_DEVICETYPE_CPU);
441     ASSERT_NE(cpu_device_info, nullptr);
442     OH_AI_DeviceInfoSetEnableFP16(cpu_device_info, true);
443     bool is_fp16 = OH_AI_DeviceInfoGetEnableFP16(cpu_device_info);
444     printf("==========is_fp16:%d\n", is_fp16);
445     ASSERT_EQ(is_fp16, true);
446     OH_AI_ContextAddDeviceInfo(context, cpu_device_info);
447     printf("==========Create model==========\n");
448     OH_AI_ModelHandle model = OH_AI_ModelCreate();
449     ASSERT_NE(model, nullptr);
450     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
451 }
452 
453 // 正常场景：Context设置CPU，关闭fp16
454 HWTEST(MSLiteTest, OHOS_Context_CPU_0015, Function | MediumTest | Level1) {
455     printf("==========Init Context==========\n");
456     OH_AI_ContextHandle context = OH_AI_ContextCreate();
457     ASSERT_NE(context, nullptr);
458     OH_AI_DeviceInfoHandle cpu_device_info = OH_AI_DeviceInfoCreate(OH_AI_DEVICETYPE_CPU);
459     ASSERT_NE(cpu_device_info, nullptr);
460     OH_AI_DeviceInfoSetEnableFP16(cpu_device_info, false);
461     bool is_fp16 = OH_AI_DeviceInfoGetEnableFP16(cpu_device_info);
462     printf("==========is_fp16:%d\n", is_fp16);
463     ASSERT_EQ(is_fp16, false);
464     OH_AI_ContextAddDeviceInfo(context, cpu_device_info);
465     printf("==========Create model==========\n");
466     OH_AI_ModelHandle model = OH_AI_ModelCreate();
467     ASSERT_NE(model, nullptr);
468     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
469 }
470 
471 // 正常场景：Context设置CPU，设置厂商名称
472 HWTEST(MSLiteTest, OHOS_Context_CPU_0016, Function | MediumTest | Level1) {
473     printf("==========Init Context==========\n");
474     OH_AI_ContextHandle context = OH_AI_ContextCreate();
475     ASSERT_NE(context, nullptr);
476     OH_AI_DeviceInfoHandle cpu_device_info = OH_AI_DeviceInfoCreate(OH_AI_DEVICETYPE_CPU);
477     ASSERT_NE(cpu_device_info, nullptr);
478     OH_AI_DeviceInfoSetProvider(cpu_device_info, "vendor_new");
479     ASSERT_EQ(strcmp(OH_AI_DeviceInfoGetProvider(cpu_device_info), "vendor_new"), 0);
480     OH_AI_ContextAddDeviceInfo(context, cpu_device_info);
481     printf("==========Create model==========\n");
482     OH_AI_ModelHandle model = OH_AI_ModelCreate();
483     ASSERT_NE(model, nullptr);
484     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
485 }
486 
487 // 正常场景：Context设置CPU，设置厂商设备类型
488 HWTEST(MSLiteTest, OHOS_Context_CPU_0017, Function | MediumTest | Level1) {
489     printf("==========Init Context==========\n");
490     OH_AI_ContextHandle context = OH_AI_ContextCreate();
491     ASSERT_NE(context, nullptr);
492     OH_AI_DeviceInfoHandle cpu_device_info = OH_AI_DeviceInfoCreate(OH_AI_DEVICETYPE_CPU);
493     ASSERT_NE(cpu_device_info, nullptr);
494     OH_AI_DeviceInfoSetProviderDevice(cpu_device_info, "cpu_new");
495     ASSERT_EQ(strcmp(OH_AI_DeviceInfoGetProviderDevice(cpu_device_info), "cpu_new"), 0);
496     OH_AI_ContextAddDeviceInfo(context, cpu_device_info);
497     printf("==========Create model==========\n");
498     OH_AI_ModelHandle model = OH_AI_ModelCreate();
499     ASSERT_NE(model, nullptr);
500     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
501 }
502 
503 // 正常场景：Context设置CPU，销毁MSDeviceInfo
504 HWTEST(MSLiteTest, OHOS_Context_CPU_0018, Function | MediumTest | Level1) {
505     printf("==========Init Context==========\n");
506     OH_AI_ContextHandle context = OH_AI_ContextCreate();
507     ASSERT_NE(context, nullptr);
508     OH_AI_DeviceInfoHandle cpu_device_info = OH_AI_DeviceInfoCreate(OH_AI_DEVICETYPE_CPU);
509     ASSERT_NE(cpu_device_info, nullptr);
510     OH_AI_DeviceType device_type = OH_AI_DeviceInfoGetDeviceType(cpu_device_info);
511     printf("==========device_type:%d\n", device_type);
512     ASSERT_EQ(device_type, OH_AI_DEVICETYPE_CPU);
513     OH_AI_ContextAddDeviceInfo(context, cpu_device_info);
514     OH_AI_DeviceInfoDestroy(&cpu_device_info);
515     ASSERT_EQ(cpu_device_info, nullptr);
516 }
517 
518 // 正常场景：Context设置CPU，销毁OH_AI_Context
519 HWTEST(MSLiteTest, OHOS_Context_CPU_0019, Function | MediumTest | Level1) {
520     printf("==========Init Context==========\n");
521     OH_AI_ContextHandle context = OH_AI_ContextCreate();
522     ASSERT_NE(context, nullptr);
523     OH_AI_DeviceInfoHandle cpu_device_info = OH_AI_DeviceInfoCreate(OH_AI_DEVICETYPE_CPU);
524     ASSERT_NE(cpu_device_info, nullptr);
525     OH_AI_DeviceType device_type = OH_AI_DeviceInfoGetDeviceType(cpu_device_info);
526     printf("==========device_type:%d\n", device_type);
527     ASSERT_EQ(device_type, OH_AI_DEVICETYPE_CPU);
528     OH_AI_ContextAddDeviceInfo(context, cpu_device_info);
529     OH_AI_ContextDestroy(&context);
530     ASSERT_EQ(context, nullptr);
531 }
532 
533 // 异常场景：Context不设置device info
534 HWTEST(MSLiteTest, OHOS_Context_CPU_0020, Function | MediumTest | Level1) {
535     printf("==========Init Context==========\n");
536     OH_AI_ContextHandle context = OH_AI_ContextCreate();
537     ASSERT_NE(context, nullptr);
538     printf("==========Create model==========\n");
539     OH_AI_ModelHandle model = OH_AI_ModelCreate();
540     ASSERT_NE(model, nullptr);
541     printf("==========Build model==========\n");
542     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_face_isface.ms", OH_AI_MODELTYPE_MINDIR, context);
543     printf("==========build model return code:%d\n", ret);
544     ASSERT_EQ(ret, OH_AI_STATUS_LITE_NULLPTR);
545     OH_AI_ModelDestroy(&model);
546 }
547 
548  // 正常场景：Context设置NPU,频率为1
549  HWTEST(MSLiteTest, OHOS_Context_NPU_0002, Function | MediumTest | Level1) {
550      printf("==========Init Context==========\n");
551      OH_AI_ContextHandle context = OH_AI_ContextCreate();
552      ASSERT_NE(context, nullptr);
553      OH_AI_DeviceInfoHandle npu_device_info = OH_AI_DeviceInfoCreate(OH_AI_DEVICETYPE_KIRIN_NPU);
554      ASSERT_NE(npu_device_info, nullptr);
555      OH_AI_DeviceInfoSetFrequency(npu_device_info, 1);
556      int frequency = OH_AI_DeviceInfoGetFrequency(npu_device_info);
557      ASSERT_EQ(frequency, 1);
558      OH_AI_ContextAddDeviceInfo(context, npu_device_info);
559      printf("==========Create model==========\n");
560      OH_AI_ModelHandle model = OH_AI_ModelCreate();
561      ASSERT_NE(model, nullptr);
562  }
563 
564 // 正常场景：ModelBuild，调用指针方法
565 HWTEST(MSLiteTest, OHOS_Model_Build_0001, Function | MediumTest | Level1) {
566     printf("==========Init Context==========\n");
567     OH_AI_ContextHandle context = OH_AI_ContextCreate();
568     ASSERT_NE(context, nullptr);
569     AddContextDeviceCPU(context);
570     printf("==========Create model==========\n");
571     OH_AI_ModelHandle model = OH_AI_ModelCreate();
572     ASSERT_NE(model, nullptr);
573     ModelPredict(model, context, "ml_face_isface", {}, true, true, false);
574 }
575 
576 // 异常场景：ModelBuild，model_data指向的不是模型数据
577 HWTEST(MSLiteTest, OHOS_Model_Build_0002, Function | MediumTest | Level1) {
578     printf("==========ReadFile==========\n");
579     size_t size1;
580     size_t *ptr_size1 = &size1;
581     const char *imagePath = "/data/test/ml_face_isface.input";
582     char *imageBuf = ReadFile(imagePath, ptr_size1);
583     ASSERT_NE(imageBuf, nullptr);
584     printf("==========Init Context==========\n");
585     OH_AI_ContextHandle context = OH_AI_ContextCreate();
586     ASSERT_NE(context, nullptr);
587     AddContextDeviceCPU(context);
588     printf("==========Create model==========\n");
589     OH_AI_ModelHandle model = OH_AI_ModelCreate();
590     ASSERT_NE(model, nullptr);
591     printf("==========Build model==========\n");
592     OH_AI_Status ret = OH_AI_ModelBuild(model, imageBuf, size1, OH_AI_MODELTYPE_MINDIR, context);
593     printf("==========build model return code:%d\n", ret);
594     ASSERT_EQ(ret, OH_AI_STATUS_LITE_ERROR);
595     delete[] imageBuf;
596     OH_AI_ModelDestroy(&model);
597 }
598 
599 // 异常场景：ModelBuild，model_data为空
600 HWTEST(MSLiteTest, OHOS_Model_Build_0003, Function | MediumTest | Level1) {
601     printf("==========Init Context==========\n");
602     OH_AI_ContextHandle context = OH_AI_ContextCreate();
603     ASSERT_NE(context, nullptr);
604     AddContextDeviceCPU(context);
605     printf("==========Create model==========\n");
606     OH_AI_ModelHandle model = OH_AI_ModelCreate();
607     ASSERT_NE(model, nullptr);
608     printf("==========Build model==========\n");
609     OH_AI_Status ret = OH_AI_ModelBuild(model, nullptr, 0, OH_AI_MODELTYPE_MINDIR, context);
610     printf("==========build model return code:%d\n", ret);
611     ASSERT_EQ(ret, OH_AI_STATUS_LITE_NULLPTR);
612     OH_AI_ModelDestroy(&model);
613 }
614 
615 // 异常场景：ModelBuild，data_size为0
616 HWTEST(MSLiteTest, OHOS_Model_Build_0004, Function | MediumTest | Level1) {
617     printf("==========ReadFile==========\n");
618     size_t size;
619     size_t *ptr_size = &size;
620     const char *graphPath = "/data/test/ml_face_isface.ms";
621     char *graphBuf = ReadFile(graphPath, ptr_size);
622     ASSERT_NE(graphBuf, nullptr);
623     printf("==========Init Context==========\n");
624     OH_AI_ContextHandle context = OH_AI_ContextCreate();
625     ASSERT_NE(context, nullptr);
626     AddContextDeviceCPU(context);
627     printf("==========Create model==========\n");
628     OH_AI_ModelHandle model = OH_AI_ModelCreate();
629     ASSERT_NE(model, nullptr);
630     printf("==========Build model==========\n");
631     OH_AI_Status ret = OH_AI_ModelBuild(model, graphBuf, 0, OH_AI_MODELTYPE_MINDIR, context);
632     printf("==========build model return code:%d\n", ret);
633     ASSERT_EQ(ret, OH_AI_STATUS_LITE_ERROR);
634     delete[] graphBuf;
635     OH_AI_ModelDestroy(&model);
636 }
637 
638 // 异常场景：ModelBuild，读取路径方法，且路径不是模型数据路径
639 HWTEST(MSLiteTest, OHOS_Model_Build_0005, Function | MediumTest | Level1) {
640     printf("==========Init Context==========\n");
641     OH_AI_ContextHandle context = OH_AI_ContextCreate();
642     ASSERT_NE(context, nullptr);
643     AddContextDeviceCPU(context);
644     printf("==========Create model==========\n");
645     OH_AI_ModelHandle model = OH_AI_ModelCreate();
646     ASSERT_NE(model, nullptr);
647     printf("==========Build model==========\n");
648     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_face_isface.input", OH_AI_MODELTYPE_MINDIR, context);
649     printf("==========build model return code:%d\n", ret);
650     ASSERT_EQ(ret, OH_AI_STATUS_LITE_ERROR);
651     OH_AI_ModelDestroy(&model);
652 }
653 
654 // 异常场景：ModelBuild，读取路径方法，路径为空
655 HWTEST(MSLiteTest, OHOS_Model_Build_0006, Function | MediumTest | Level1) {
656     printf("==========Init Context==========\n");
657     OH_AI_ContextHandle context = OH_AI_ContextCreate();
658     ASSERT_NE(context, nullptr);
659     AddContextDeviceCPU(context);
660     printf("==========Create model==========\n");
661     OH_AI_ModelHandle model = OH_AI_ModelCreate();
662     ASSERT_NE(model, nullptr);
663     printf("==========Build model==========\n");
664     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "", OH_AI_MODELTYPE_MINDIR, context);
665     printf("==========build model return code:%d\n", ret);
666     ASSERT_EQ(ret, OH_AI_STATUS_LITE_ERROR);
667     OH_AI_ModelDestroy(&model);
668 }
669 
670 // 异常场景：ModelBuild，model_type不支持
671 HWTEST(MSLiteTest, OHOS_Model_Build_0007, Function | MediumTest | Level1) {
672     printf("==========Init Context==========\n");
673     OH_AI_ContextHandle context = OH_AI_ContextCreate();
674     ASSERT_NE(context, nullptr);
675     AddContextDeviceCPU(context);
676     printf("==========Create model==========\n");
677     OH_AI_ModelHandle model = OH_AI_ModelCreate();
678     ASSERT_NE(model, nullptr);
679     printf("==========Build model==========\n");
680     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_face_isface.ms", OH_AI_MODELTYPE_INVALID, context);
681     printf("==========build model return code:%d\n", ret);
682     ASSERT_EQ(ret, OH_AI_STATUS_LITE_PARAM_INVALID);
683     OH_AI_ModelDestroy(&model);
684 }
685 
686 // 异常场景：ModelBuild，model_context为空
687 HWTEST(MSLiteTest, OHOS_Model_Build_0008, Function | MediumTest | Level1) {
688     printf("==========Init Context==========\n");
689     OH_AI_ContextHandle context = OH_AI_ContextCreate();
690     ASSERT_NE(context, nullptr);
691     AddContextDeviceCPU(context);
692     printf("==========Create model==========\n");
693     OH_AI_ModelHandle model = OH_AI_ModelCreate();
694     ASSERT_NE(model, nullptr);
695     printf("==========Build model==========\n");
696     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_face_isface.ms", OH_AI_MODELTYPE_MINDIR, nullptr);
697     printf("==========build model return code:%d\n", ret);
698     ASSERT_EQ(ret, OH_AI_STATUS_LITE_NULLPTR);
699     OH_AI_ModelDestroy(&model);
700 }
701 
702 // 正常场景：ModelBuild，调用GetOutputs获取输出
703 HWTEST(MSLiteTest, OHOS_Model_Build_0009, Function | MediumTest | Level1) {
704     printf("==========Init Context==========\n");
705     OH_AI_ContextHandle context = OH_AI_ContextCreate();
706     ASSERT_NE(context, nullptr);
707     AddContextDeviceCPU(context);
708     printf("==========Create model==========\n");
709     OH_AI_ModelHandle model = OH_AI_ModelCreate();
710     ASSERT_NE(model, nullptr);
711     printf("==========Model build==========\n");
712     OH_AI_ModelBuildFromFile(model,"/data/test/ml_face_isface.ms", OH_AI_MODELTYPE_MINDIR, context);
713     printf("==========Model Predict==========\n");
714     OH_AI_TensorHandleArray inputs = OH_AI_ModelGetInputs(model);
715     OH_AI_TensorHandleArray output;
716     FillInputsData(inputs,"ml_face_isface",false);
717     OH_AI_Status ret = OH_AI_ModelPredict(model, inputs, &output, nullptr, nullptr);
718     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
719     printf("==========GetOutput==========\n");
720     OH_AI_TensorHandleArray outputs = OH_AI_ModelGetOutputs(model);
721     for (size_t i = 0; i < outputs.handle_num; ++i) {
722         OH_AI_TensorHandle tensor = outputs.handle_list[i];
723         int64_t element_num = OH_AI_TensorGetElementNum(tensor);
724         printf("Tensor name: %s, elements num: %" PRId64 ".\n", OH_AI_TensorGetName(tensor), element_num);
725         float *output_data = reinterpret_cast<float *>(OH_AI_TensorGetMutableData(tensor));
726         printf("output data is:");
727         for (int j = 0; j < element_num && j <= 20; ++j) {
728             printf("%f ", output_data[j]);
729         }
730         printf("\n");
731         printf("==========compFp32WithTData==========\n");
732         string expectedDataFile = "/data/test/ml_face_isface" + std::to_string(i) + ".output";
733         bool result = compFp32WithTData(output_data, expectedDataFile, 0.01, 0.01, false);
734         EXPECT_EQ(result, true);
735     }
736 }
737 
738 // 正常场景：ModelResize，shape与之前一致
739 HWTEST(MSLiteTest, OHOS_Model_Resize_0001, Function | MediumTest | Level1) {
740     printf("==========Init Context==========\n");
741     OH_AI_ContextHandle context = OH_AI_ContextCreate();
742     ASSERT_NE(context, nullptr);
743     AddContextDeviceCPU(context);
744     printf("==========Create model==========\n");
745     OH_AI_ModelHandle model = OH_AI_ModelCreate();
746     ASSERT_NE(model, nullptr);
747     ModelPredict(model, context, "ml_ocr_cn", {4, {1, 32, 512, 1}}, false, true, false);
748 }
749 
750 // 正常场景：ModelResize，shape与之前不一致
751 HWTEST(MSLiteTest, OHOS_Model_Resize_0002, Function | MediumTest | Level1) {
752     printf("==========Init Context==========\n");
753     OH_AI_ContextHandle context = OH_AI_ContextCreate();
754     ASSERT_NE(context, nullptr);
755     AddContextDeviceCPU(context);
756     printf("==========Create model==========\n");
757     OH_AI_ModelHandle model = OH_AI_ModelCreate();
758     ASSERT_NE(model, nullptr);
759     printf("==========Build model==========\n");
760     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_ocr_cn.ms", OH_AI_MODELTYPE_MINDIR, context);
761     printf("==========build model return code:%d\n", ret);
762     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
763     printf("==========GetInputs==========\n");
764     OH_AI_TensorHandleArray inputs = OH_AI_ModelGetInputs(model);
765     ASSERT_NE(inputs.handle_list, nullptr);
766     printf("==========Resizes==========\n");
767     OH_AI_ShapeInfo shape_infos = {4, {1, 64, 256, 1}};
768     OH_AI_Status resize_ret = OH_AI_ModelResize(model, inputs, &shape_infos, inputs.handle_num);
769     printf("==========Resizes return code:%d\n", resize_ret);
770     ASSERT_EQ(resize_ret, OH_AI_STATUS_SUCCESS);
771     FillInputsData(inputs, "ml_ocr_cn", false);
772     OH_AI_TensorHandleArray outputs;
773     printf("==========Model Predict==========\n");
774     OH_AI_Status predict_ret = OH_AI_ModelPredict(model, inputs, &outputs, nullptr, nullptr);
775     ASSERT_EQ(predict_ret, OH_AI_STATUS_SUCCESS);
776 }
777 
778 // 异常场景：ModelResize，shape为三维
779 HWTEST(MSLiteTest, OHOS_Model_Resize_0003, Function | MediumTest | Level1) {
780     printf("==========Init Context==========\n");
781     OH_AI_ContextHandle context = OH_AI_ContextCreate();
782     ASSERT_NE(context, nullptr);
783     AddContextDeviceCPU(context);
784     printf("==========Create model==========\n");
785     OH_AI_ModelHandle model = OH_AI_ModelCreate();
786     ASSERT_NE(model, nullptr);
787     printf("==========Build model==========\n");
788     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_ocr_cn.ms", OH_AI_MODELTYPE_MINDIR, context);
789     printf("==========build model return code:%d\n", ret);
790     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
791     printf("==========GetInputs==========\n");
792     OH_AI_TensorHandleArray inputs = OH_AI_ModelGetInputs(model);
793     ASSERT_NE(inputs.handle_list, nullptr);
794     printf("==========Resizes==========\n");
795     OH_AI_ShapeInfo shape_infos = {4, {1, 32, 1}};
796     ret = OH_AI_ModelResize(model, inputs, &shape_infos, inputs.handle_num);
797     printf("==========Resizes return code:%d\n", ret);
798     ASSERT_EQ(ret, OH_AI_STATUS_LITE_ERROR);
799     OH_AI_ModelDestroy(&model);
800 }
801 
802 // 异常场景：ModelResize，shape值有负数
803 HWTEST(MSLiteTest, OHOS_Model_Resize_0004, Function | MediumTest | Level1) {
804     printf("==========Init Context==========\n");
805     OH_AI_ContextHandle context = OH_AI_ContextCreate();
806     ASSERT_NE(context, nullptr);
807     AddContextDeviceCPU(context);
808     printf("==========Create model==========\n");
809     OH_AI_ModelHandle model = OH_AI_ModelCreate();
810     ASSERT_NE(model, nullptr);
811     printf("==========Build model==========\n");
812     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_ocr_cn.ms", OH_AI_MODELTYPE_MINDIR, context);
813     printf("==========build model return code:%d\n", ret);
814     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
815     printf("==========GetInputs==========\n");
816     OH_AI_TensorHandleArray inputs = OH_AI_ModelGetInputs(model);
817     ASSERT_NE(inputs.handle_list, nullptr);
818     printf("==========Resizes==========\n");
819     OH_AI_ShapeInfo shape_infos = {4, {1, -32, 32, 1}};
820     ret = OH_AI_ModelResize(model, inputs, &shape_infos, inputs.handle_num);
821     printf("==========Resizes return code:%d\n", ret);
822     ASSERT_EQ(ret, OH_AI_STATUS_LITE_ERROR);
823     OH_AI_ModelDestroy(&model);
824 }
825 
826 // 异常场景：ModelResize，不支持resize的模型
827 HWTEST(MSLiteTest, OHOS_Model_Resize_0005, Function | MediumTest | Level1) {
828     printf("==========Init Context==========\n");
829     OH_AI_ContextHandle context = OH_AI_ContextCreate();
830     ASSERT_NE(context, nullptr);
831     AddContextDeviceCPU(context);
832     printf("==========Create model==========\n");
833     OH_AI_ModelHandle model = OH_AI_ModelCreate();
834     ASSERT_NE(model, nullptr);
835     printf("==========Build model==========\n");
836     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_face_isface.ms", OH_AI_MODELTYPE_MINDIR, context);
837     printf("==========build model return code:%d\n", ret);
838     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
839     printf("==========GetInputs==========\n");
840     OH_AI_TensorHandleArray inputs = OH_AI_ModelGetInputs(model);
841     ASSERT_NE(inputs.handle_list, nullptr);
842     printf("==========Resizes==========\n");
843     OH_AI_ShapeInfo shape_infos = {4, {1, 96, 96, 1}};
844     ret = OH_AI_ModelResize(model, inputs, &shape_infos, inputs.handle_num);
845     printf("==========Resizes return code:%d\n", ret);
846     ASSERT_EQ(ret, OH_AI_STATUS_LITE_ERROR);
847     OH_AI_ModelDestroy(&model);
848 }
849 
850 // 正常场景：ModelPredict
851 HWTEST(MSLiteTest, OHOS_Model_Predict_0001, Function | MediumTest | Level1) {
852     printf("==========Init Context==========\n");
853     OH_AI_ContextHandle context = OH_AI_ContextCreate();
854     ASSERT_NE(context, nullptr);
855     AddContextDeviceCPU(context);
856     printf("==========Create model==========\n");
857     OH_AI_ModelHandle model = OH_AI_ModelCreate();
858     ASSERT_NE(model, nullptr);
859     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
860 }
861 
862 // 异常场景：ModelPredict，model被销毁
863 HWTEST(MSLiteTest, OHOS_Model_Predict_0002, Function | MediumTest | Level1) {
864     printf("==========Init Context==========\n");
865     OH_AI_ContextHandle context = OH_AI_ContextCreate();
866     ASSERT_NE(context, nullptr);
867     AddContextDeviceCPU(context);
868     printf("==========Create model==========\n");
869     OH_AI_ModelHandle model = OH_AI_ModelCreate();
870     ASSERT_NE(model, nullptr);
871     printf("==========Build model==========\n");
872     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_face_isface.ms", OH_AI_MODELTYPE_MINDIR, context);
873     printf("==========build model return code:%d\n", ret);
874     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
875     printf("==========GetInputs==========\n");
876     OH_AI_TensorHandleArray inputs = OH_AI_ModelGetInputs(model);
877     ASSERT_NE(inputs.handle_list, nullptr);
878     FillInputsData(inputs, "ml_face_isface", true);
879     printf("==========Model Predict==========\n");
880     OH_AI_TensorHandleArray outputs;
881     OH_AI_ModelDestroy(&model);
882     ret = OH_AI_ModelPredict(model, inputs, &outputs, nullptr, nullptr);
883     printf("==========Model Predict return code:%d\n", ret);
884     ASSERT_EQ(ret, OH_AI_STATUS_LITE_NULLPTR);
885 }
886 
887 // 异常场景：ModelPredict，input为空
888 HWTEST(MSLiteTest, OHOS_Model_Predict_0003, Function | MediumTest | Level1) {
889     printf("==========Init Context==========\n");
890     OH_AI_ContextHandle context = OH_AI_ContextCreate();
891     ASSERT_NE(context, nullptr);
892     AddContextDeviceCPU(context);
893     printf("==========Create model==========\n");
894     OH_AI_ModelHandle model = OH_AI_ModelCreate();
895     ASSERT_NE(model, nullptr);
896     printf("==========Build model==========\n");
897     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_face_isface.ms", OH_AI_MODELTYPE_MINDIR, context);
898     printf("==========build model return code:%d\n", ret);
899     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
900     printf("==========Model Predict==========\n");
901     OH_AI_TensorHandleArray inputs;
902     OH_AI_TensorHandleArray outputs;
903     ret = OH_AI_ModelPredict(model, inputs, &outputs, nullptr, nullptr);
904     printf("==========Model Predict return code:%d\n", ret);
905     ASSERT_EQ(ret, OH_AI_STATUS_LITE_ERROR);
906     OH_AI_ModelDestroy(&model);
907 }
908 
909 // 正常场景：ModelPredict，传入回调函数
910 HWTEST(MSLiteTest, OHOS_Model_Predict_0004, Function | MediumTest | Level1) {
911     printf("==========Init Context==========\n");
912     OH_AI_ContextHandle context = OH_AI_ContextCreate();
913     ASSERT_NE(context, nullptr);
914     AddContextDeviceCPU(context);
915     printf("==========Create model==========\n");
916     OH_AI_ModelHandle model = OH_AI_ModelCreate();
917     ASSERT_NE(model, nullptr);
918     ModelPredict(model, context, "ml_face_isface", {}, false, true, true);
919 }
920 
921 // 正常场景：ModelGetInputByTensorName
922 HWTEST(MSLiteTest, OHOS_Model_GetInputByTensorName_0001, Function | MediumTest | Level1) {
923     printf("==========ReadFile==========\n");
924     size_t size1;
925     size_t *ptr_size1 = &size1;
926     const char *imagePath = "/data/test/ml_face_isface.input";
927     char *imageBuf = ReadFile(imagePath, ptr_size1);
928     ASSERT_NE(imageBuf, nullptr);
929     printf("==========Init Context==========\n");
930     OH_AI_ContextHandle context = OH_AI_ContextCreate();
931     ASSERT_NE(context, nullptr);
932     AddContextDeviceCPU(context);
933     printf("==========Create model==========\n");
934     OH_AI_ModelHandle model = OH_AI_ModelCreate();
935     ASSERT_NE(model, nullptr);
936     printf("==========Build model==========\n");
937     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_face_isface.ms", OH_AI_MODELTYPE_MINDIR, context);
938     printf("==========build model return code:%d\n", ret);
939     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
940     printf("==========GetInputs==========\n");
941     OH_AI_TensorHandle tensor = OH_AI_ModelGetInputByTensorName(model, "data");
942     ASSERT_NE(tensor, nullptr);
943     int64_t element_num = OH_AI_TensorGetElementNum(tensor);
944     printf("Tensor name: %s, elements num: %" PRId64 ".\n", OH_AI_TensorGetName(tensor), element_num);
945     float *input_data = reinterpret_cast<float *>(OH_AI_TensorGetMutableData(tensor));
946     ASSERT_NE(input_data, nullptr);
947     printf("==========Transpose==========\n");
948     size_t shape_num;
949     const int64_t *shape = OH_AI_TensorGetShape(tensor, &shape_num);
950     auto imageBuf_nhwc = new char[size1];
951     PackNCHWToNHWCFp32(imageBuf, imageBuf_nhwc, shape[0], shape[1] * shape[2], shape[3]);
952     memcpy_s(input_data, size1, imageBuf_nhwc, size1);
953     printf("input data is:");
954     for (int j = 0; j < element_num && j <= 20; ++j) {
955         printf("%f ", input_data[j]);
956     }
957     printf("\n");
958     printf("==========Model Predict==========\n");
959     OH_AI_TensorHandleArray inputs = OH_AI_ModelGetInputs(model);
960     ASSERT_NE(inputs.handle_list, nullptr);
961     OH_AI_TensorHandleArray outputs;
962     ret = OH_AI_ModelPredict(model, inputs, &outputs, nullptr, nullptr);
963     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
964     CompareResult(outputs, "ml_face_isface");
965     delete[] imageBuf;
966     OH_AI_ModelDestroy(&model);
967 }
968 
969 // 异常场景：ModelGetInputByTensorName，名称不存在
970 HWTEST(MSLiteTest, OHOS_Model_GetInputByTensorName_0002, Function | MediumTest | Level1) {
971     printf("==========Init Context==========\n");
972     OH_AI_ContextHandle context = OH_AI_ContextCreate();
973     ASSERT_NE(context, nullptr);
974     AddContextDeviceCPU(context);
975     printf("==========Create model==========\n");
976     OH_AI_ModelHandle model = OH_AI_ModelCreate();
977     ASSERT_NE(model, nullptr);
978     printf("==========Build model==========\n");
979     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_face_isface.ms", OH_AI_MODELTYPE_MINDIR, context);
980     printf("==========build model return code:%d\n", ret);
981     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
982     printf("==========GetInputs==========\n");
983     OH_AI_TensorHandle tensor = OH_AI_ModelGetInputByTensorName(model, "aaa");
984     ASSERT_EQ(tensor, nullptr);
985     OH_AI_ModelDestroy(&model);
986 }
987 
988 // 正常场景：ModelGetOutputByTensorName
989 HWTEST(MSLiteTest, OHOS_Model_GetOutputByTensorName_0001, Function | MediumTest | Level1) {
990     printf("==========Init Context==========\n");
991     OH_AI_ContextHandle context = OH_AI_ContextCreate();
992     ASSERT_NE(context, nullptr);
993     AddContextDeviceCPU(context);
994     printf("==========Create model==========\n");
995     OH_AI_ModelHandle model = OH_AI_ModelCreate();
996     ASSERT_NE(model, nullptr);
997     printf("==========Build model==========\n");
998     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_face_isface.ms", OH_AI_MODELTYPE_MINDIR, context);
999     printf("==========build model return code:%d\n", ret);
1000     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
1001     printf("==========GetInputs==========\n");
1002     OH_AI_TensorHandleArray inputs = OH_AI_ModelGetInputs(model);
1003     ASSERT_NE(inputs.handle_list, nullptr);
1004     FillInputsData(inputs, "ml_face_isface", true);
1005     printf("==========Model Predict==========\n");
1006     OH_AI_TensorHandleArray outputs;
1007     ret = OH_AI_ModelPredict(model, inputs, &outputs, nullptr, nullptr);
1008     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
1009     printf("==========GetOutput==========\n");
1010     OH_AI_TensorHandle tensor = OH_AI_ModelGetOutputByTensorName(model, "prob");
1011     ASSERT_NE(tensor, nullptr);
1012     int64_t element_num = OH_AI_TensorGetElementNum(tensor);
1013     printf("Tensor name: %s, elements num: %" PRId64 ".\n", OH_AI_TensorGetName(tensor), element_num);
1014     float *output_data = reinterpret_cast<float *>(OH_AI_TensorGetMutableData(tensor));
1015     printf("output data is:");
1016     for (int j = 0; j < element_num && j <= 20; ++j) {
1017         printf("%f ", output_data[j]);
1018     }
1019     printf("\n");
1020     printf("==========compFp32WithTData==========\n");
1021     bool result = compFp32WithTData(output_data, "/data/test/ml_face_isface0.output", 0.01, 0.01, false);
1022     EXPECT_EQ(result, true);
1023     OH_AI_ModelDestroy(&model);
1024 }
1025 
1026 // 异常场景：ModelGetOutputByTensorName，名称不存在
1027 HWTEST(MSLiteTest, OHOS_Model_GetOutputByTensorName_0002, Function | MediumTest | Level1) {
1028     printf("==========Init Context==========\n");
1029     OH_AI_ContextHandle context = OH_AI_ContextCreate();
1030     ASSERT_NE(context, nullptr);
1031     AddContextDeviceCPU(context);
1032     printf("==========Create model==========\n");
1033     OH_AI_ModelHandle model = OH_AI_ModelCreate();
1034     ASSERT_NE(model, nullptr);
1035     printf("==========Build model==========\n");
1036     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_face_isface.ms", OH_AI_MODELTYPE_MINDIR, context);
1037     printf("==========build model return code:%d\n", ret);
1038     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
1039     printf("==========GetInputs==========\n");
1040     OH_AI_TensorHandleArray inputs = OH_AI_ModelGetInputs(model);
1041     ASSERT_NE(inputs.handle_list, nullptr);
1042     FillInputsData(inputs, "ml_face_isface", true);
1043     printf("==========Model Predict==========\n");
1044     OH_AI_TensorHandleArray outputs;
1045     ret = OH_AI_ModelPredict(model, inputs, &outputs, nullptr, nullptr);
1046     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
1047     printf("==========GetOutput==========\n");
1048     OH_AI_TensorHandle tensor = OH_AI_ModelGetOutputByTensorName(model, "aaa");
1049     ASSERT_EQ(tensor, nullptr);
1050     OH_AI_ModelDestroy(&model);
1051 }
1052 
1053 // 正常场景：MSTensorCreate,创建tensor
1054 HWTEST(MSLiteTest, OHOS_Tensor_Create_0001, Function | MediumTest | Level1) {
1055     printf("==========Init Context==========\n");
1056     OH_AI_ContextHandle context = OH_AI_ContextCreate();
1057     ASSERT_NE(context, nullptr);
1058     AddContextDeviceCPU(context);
1059     printf("==========Create model==========\n");
1060     OH_AI_ModelHandle model = OH_AI_ModelCreate();
1061     ASSERT_NE(model, nullptr);
1062     printf("==========Build model==========\n");
1063     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_face_isface.ms", OH_AI_MODELTYPE_MINDIR, context);
1064     printf("==========build model return code:%d\n", ret);
1065     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
1066     printf("==========GetInputs==========\n");
1067     constexpr size_t create_shape_num = 4;
1068     int64_t create_shape[create_shape_num] = {1, 48, 48, 3};
1069     OH_AI_TensorHandle tensor = OH_AI_TensorCreate("data", OH_AI_DATATYPE_NUMBERTYPE_FLOAT32, create_shape,
1070                             create_shape_num, nullptr, 0);
1071     ASSERT_NE(tensor, nullptr);
1072     OH_AI_TensorHandleArray inputs = OH_AI_ModelGetInputs(model);
1073     inputs.handle_list[0] = tensor;
1074     FillInputsData(inputs, "ml_face_isface", true);
1075     printf("==========Model Predict==========\n");
1076     OH_AI_TensorHandleArray outputs;
1077     ret = OH_AI_ModelPredict(model, inputs, &outputs, nullptr, nullptr);
1078     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
1079     CompareResult(outputs, "ml_face_isface");
1080     OH_AI_ModelDestroy(&model);
1081 }
1082 
1083 // 正常场景：MSTensorDestroy,销毁tensor
1084 HWTEST(MSLiteTest, OHOS_Tensor_Create_0002, Function | MediumTest | Level1) {
1085     printf("==========ReadFile==========\n");
1086     size_t size1;
1087     size_t *ptr_size1 = &size1;
1088     const char *imagePath = "/data/test/ml_face_isface.input";
1089     char *imageBuf = ReadFile(imagePath, ptr_size1);
1090     ASSERT_NE(imageBuf, nullptr);
1091     printf("==========OH_AI_TensorCreate==========\n");
1092     constexpr size_t create_shape_num = 4;
1093     int64_t create_shape[create_shape_num] = {1, 48, 48, 3};
1094     OH_AI_TensorHandle tensor = OH_AI_TensorCreate("data", OH_AI_DATATYPE_NUMBERTYPE_FLOAT32, create_shape,
1095                                            create_shape_num, imageBuf, size1);
1096     ASSERT_NE(tensor, nullptr);
1097     delete[] imageBuf;
1098     OH_AI_TensorDestroy(&tensor);
1099     ASSERT_EQ(tensor, nullptr);
1100 }
1101 
1102 // 正常场景：MSTensorGetName,获取tensor名称
1103 HWTEST(MSLiteTest, OHOS_Tensor_Create_0003, Function | MediumTest | Level1) {
1104     printf("==========ReadFile==========\n");
1105     size_t size1;
1106     size_t *ptr_size1 = &size1;
1107     const char *imagePath = "/data/test/ml_face_isface.input";
1108     char *imageBuf = ReadFile(imagePath, ptr_size1);
1109     ASSERT_NE(imageBuf, nullptr);
1110     printf("==========OH_AI_TensorCreate==========\n");
1111     constexpr size_t create_shape_num = 4;
1112     int64_t create_shape[create_shape_num] = {1, 48, 48, 3};
1113     OH_AI_TensorHandle tensor = OH_AI_TensorCreate("data", OH_AI_DATATYPE_NUMBERTYPE_FLOAT32, create_shape,
1114                                             create_shape_num, imageBuf, size1);
1115     ASSERT_NE(tensor, nullptr);
1116     const char *tensor_name = OH_AI_TensorGetName(tensor);
1117     ASSERT_EQ(strcmp(tensor_name, "data"), 0);
1118     delete[] imageBuf;
1119     OH_AI_TensorDestroy(&tensor);
1120 }
1121 
1122 // 正常场景：MSTensorGetName,设置tensor名称
1123 HWTEST(MSLiteTest, OHOS_Tensor_Create_0004, Function | MediumTest | Level1) {
1124     printf("==========ReadFile==========\n");
1125     size_t size1;
1126     size_t *ptr_size1 = &size1;
1127     const char *imagePath = "/data/test/ml_face_isface.input";
1128     char *imageBuf = ReadFile(imagePath, ptr_size1);
1129     ASSERT_NE(imageBuf, nullptr);
1130     printf("==========OH_AI_TensorCreate==========\n");
1131     constexpr size_t create_shape_num = 4;
1132     int64_t create_shape[create_shape_num] = {1, 48, 48, 3};
1133     OH_AI_TensorHandle tensor = OH_AI_TensorCreate("data", OH_AI_DATATYPE_NUMBERTYPE_FLOAT32, create_shape,
1134                                            create_shape_num, imageBuf, size1);
1135     ASSERT_NE(tensor, nullptr);
1136     OH_AI_TensorSetName(tensor, "new_data");
1137     const char *tensor_name = OH_AI_TensorGetName(tensor);
1138     ASSERT_EQ(strcmp(tensor_name, "new_data"), 0);
1139     delete[] imageBuf;
1140     OH_AI_TensorDestroy(&tensor);
1141 }
1142 
1143 // 正常场景：MSTensorGetDataType,获取tensor数据类型
1144 HWTEST(MSLiteTest, OHOS_Tensor_Create_0005, Function | MediumTest | Level1) {
1145     printf("==========ReadFile==========\n");
1146     size_t size1;
1147     size_t *ptr_size1 = &size1;
1148     const char *imagePath = "/data/test/ml_face_isface.input";
1149     char *imageBuf = ReadFile(imagePath, ptr_size1);
1150     ASSERT_NE(imageBuf, nullptr);
1151     printf("==========OH_AI_TensorCreate==========\n");
1152     constexpr size_t create_shape_num = 4;
1153     int64_t create_shape[create_shape_num] = {1, 48, 48, 3};
1154     OH_AI_TensorHandle tensor = OH_AI_TensorCreate("data", OH_AI_DATATYPE_NUMBERTYPE_FLOAT32, create_shape,
1155                                            create_shape_num, imageBuf, size1);
1156     ASSERT_NE(tensor, nullptr);
1157     OH_AI_DataType data_type = OH_AI_TensorGetDataType(tensor);
1158     ASSERT_EQ(data_type, OH_AI_DATATYPE_NUMBERTYPE_FLOAT32);
1159     delete[] imageBuf;
1160     OH_AI_TensorDestroy(&tensor);
1161 }
1162 
1163 // 正常场景：MSTensorSetDataType,设置tensor数据类型
1164 HWTEST(MSLiteTest, OHOS_Tensor_Create_0006, Function | MediumTest | Level1) {
1165     printf("==========ReadFile==========\n");
1166     size_t size1;
1167     size_t *ptr_size1 = &size1;
1168     const char *imagePath = "/data/test/ml_face_isface.input";
1169     char *imageBuf = ReadFile(imagePath, ptr_size1);
1170     ASSERT_NE(imageBuf, nullptr);
1171     printf("==========OH_AI_TensorCreate==========\n");
1172     constexpr size_t create_shape_num = 4;
1173     int64_t create_shape[create_shape_num] = {1, 48, 48, 3};
1174     OH_AI_TensorHandle tensor = OH_AI_TensorCreate("data", OH_AI_DATATYPE_NUMBERTYPE_FLOAT32, create_shape,
1175                                            create_shape_num, imageBuf, size1);
1176     ASSERT_NE(tensor, nullptr);
1177     OH_AI_TensorSetDataType(tensor, OH_AI_DATATYPE_NUMBERTYPE_FLOAT16);
1178     OH_AI_DataType data_type = OH_AI_TensorGetDataType(tensor);
1179     ASSERT_EQ(data_type, OH_AI_DATATYPE_NUMBERTYPE_FLOAT16);
1180     delete[] imageBuf;
1181     OH_AI_TensorDestroy(&tensor);
1182 }
1183 
1184 // 正常场景：MSTensorGetShape,获取tensor维度
1185 HWTEST(MSLiteTest, OHOS_Tensor_Create_0007, Function | MediumTest | Level1) {
1186     printf("==========ReadFile==========\n");
1187     size_t size1;
1188     size_t *ptr_size1 = &size1;
1189     const char *imagePath = "/data/test/ml_face_isface.input";
1190     char *imageBuf = ReadFile(imagePath, ptr_size1);
1191     ASSERT_NE(imageBuf, nullptr);
1192     printf("==========OH_AI_TensorCreate==========\n");
1193     constexpr size_t create_shape_num = 4;
1194     int64_t create_shape[create_shape_num] = {1, 48, 48, 3};
1195     OH_AI_TensorHandle tensor = OH_AI_TensorCreate("data", OH_AI_DATATYPE_NUMBERTYPE_FLOAT32, create_shape,
1196                                             create_shape_num, imageBuf, size1);
1197     ASSERT_NE(tensor, nullptr);
1198     size_t ret_shape_num;
1199     const int64_t *ret_shape = OH_AI_TensorGetShape(tensor, &ret_shape_num);
1200     ASSERT_EQ(ret_shape_num, create_shape_num);
1201     for (size_t i = 0; i < ret_shape_num; i++) {
1202         ASSERT_EQ(ret_shape[i], create_shape[i]);
1203     }
1204     delete[] imageBuf;
1205     OH_AI_TensorDestroy(&tensor);
1206 }
1207 
1208 // 正常场景：MSTensorSetShape,设置tensor维度
1209 HWTEST(MSLiteTest, OHOS_Tensor_Create_0008, Function | MediumTest | Level1) {
1210     printf("==========ReadFile==========\n");
1211     size_t size1;
1212     size_t *ptr_size1 = &size1;
1213     const char *imagePath = "/data/test/ml_face_isface.input";
1214     char *imageBuf = ReadFile(imagePath, ptr_size1);
1215     ASSERT_NE(imageBuf, nullptr);
1216     printf("==========OH_AI_TensorCreate==========\n");
1217     constexpr size_t create_shape_num = 4;
1218     int64_t create_shape[create_shape_num] = {1, 48, 48, 3};
1219     OH_AI_TensorHandle tensor = OH_AI_TensorCreate("data", OH_AI_DATATYPE_NUMBERTYPE_FLOAT32, create_shape,
1220                                            create_shape_num, imageBuf, size1);
1221     ASSERT_NE(tensor, nullptr);
1222     size_t ret_shape_num;
1223     const int64_t *ret_shape = OH_AI_TensorGetShape(tensor, &ret_shape_num);
1224     ASSERT_EQ(ret_shape_num, create_shape_num);
1225     for (size_t i = 0; i < ret_shape_num; i++) {
1226         ASSERT_EQ(ret_shape[i], create_shape[i]);
1227     }
1228     constexpr size_t new_shape_num = 4;
1229     int64_t new_shape[new_shape_num] = {1, 32, 32, 1};
1230     OH_AI_TensorSetShape(tensor, new_shape, new_shape_num);
1231     size_t new_ret_shape_num;
1232     const int64_t *new_ret_shape = OH_AI_TensorGetShape(tensor, &new_ret_shape_num);
1233     ASSERT_EQ(new_ret_shape_num, new_shape_num);
1234     for (size_t i = 0; i < new_ret_shape_num; i++) {
1235         ASSERT_EQ(new_ret_shape[i], new_shape[i]);
1236     }
1237     delete[] imageBuf;
1238     OH_AI_TensorDestroy(&tensor);
1239 }
1240 
1241 // 正常场景：MSTensorGetFormat,获取tensor格式
1242 HWTEST(MSLiteTest, OHOS_Tensor_Create_0009, Function | MediumTest | Level1) {
1243     printf("==========ReadFile==========\n");
1244     size_t size1;
1245     size_t *ptr_size1 = &size1;
1246     const char *imagePath = "/data/test/ml_face_isface.input";
1247     char *imageBuf = ReadFile(imagePath, ptr_size1);
1248     ASSERT_NE(imageBuf, nullptr);
1249     printf("==========OH_AI_TensorCreate==========\n");
1250     constexpr size_t create_shape_num = 4;
1251     int64_t create_shape[create_shape_num] = {1, 48, 48, 3};
1252     OH_AI_TensorHandle tensor = OH_AI_TensorCreate("data", OH_AI_DATATYPE_NUMBERTYPE_FLOAT32, create_shape,
1253                                            create_shape_num, imageBuf, size1);
1254     ASSERT_NE(tensor, nullptr);
1255     OH_AI_Format data_format = OH_AI_TensorGetFormat(tensor);
1256     ASSERT_EQ(data_format, OH_AI_FORMAT_NCHW);
1257     delete[] imageBuf;
1258     OH_AI_TensorDestroy(&tensor);
1259 }
1260 
1261 // 正常场景：MSTensorSetFormat,设置tensor格式
1262 HWTEST(MSLiteTest, OHOS_Tensor_Create_0010, Function | MediumTest | Level1) {
1263     printf("==========ReadFile==========\n");
1264     size_t size1;
1265     size_t *ptr_size1 = &size1;
1266     const char *imagePath = "/data/test/ml_face_isface.input";
1267     char *imageBuf = ReadFile(imagePath, ptr_size1);
1268     ASSERT_NE(imageBuf, nullptr);
1269     printf("==========OH_AI_TensorCreate==========\n");
1270     constexpr size_t create_shape_num = 4;
1271     int64_t create_shape[create_shape_num] = {1, 48, 48, 3};
1272     OH_AI_TensorHandle tensor = OH_AI_TensorCreate("data", OH_AI_DATATYPE_NUMBERTYPE_FLOAT32, create_shape,
1273                                            create_shape_num, imageBuf, size1);
1274     ASSERT_NE(tensor, nullptr);
1275     OH_AI_TensorSetFormat(tensor, OH_AI_FORMAT_NHWC);
1276     OH_AI_Format data_format = OH_AI_TensorGetFormat(tensor);
1277     ASSERT_EQ(data_format, OH_AI_FORMAT_NHWC);
1278     delete[] imageBuf;
1279     OH_AI_TensorDestroy(&tensor);
1280 }
1281 
1282 // 正常场景：MSTensorGetData,获取tensor数据
1283 HWTEST(MSLiteTest, OHOS_Tensor_Create_0011, Function | MediumTest | Level1) {
1284     printf("==========ReadFile==========\n");
1285     size_t size1;
1286     size_t *ptr_size1 = &size1;
1287     const char *imagePath = "/data/test/ml_face_isface.input";
1288     char *imageBuf = ReadFile(imagePath, ptr_size1);
1289     ASSERT_NE(imageBuf, nullptr);
1290     printf("==========OH_AI_TensorCreate==========\n");
1291     constexpr size_t create_shape_num = 4;
1292     int64_t create_shape[create_shape_num] = {1, 48, 48, 3};
1293     OH_AI_TensorHandle tensor = OH_AI_TensorCreate("data", OH_AI_DATATYPE_NUMBERTYPE_FLOAT32, create_shape,
1294                                            create_shape_num, imageBuf, size1);
1295     ASSERT_NE(tensor, nullptr);
1296     const float *ret_data = static_cast<const float *>(OH_AI_TensorGetData(tensor));
1297     ASSERT_NE(ret_data, nullptr);
1298     printf("return data is:");
1299     for (int i = 0; i < 20; ++i) {
1300         printf("%f ", ret_data[i]);
1301     }
1302     printf("\n");
1303     delete[] imageBuf;
1304     OH_AI_TensorDestroy(&tensor);
1305 }
1306 
1307 // 正常场景：MSTensorSetData,设置tensor数据
1308 HWTEST(MSLiteTest, OHOS_Tensor_Create_0012, Function | MediumTest | Level1) {
1309     printf("==========ReadFile==========\n");
1310     size_t size1;
1311     size_t *ptr_size1 = &size1;
1312     const char *imagePath = "/data/test/ml_face_isface.input";
1313     char *imageBuf = ReadFile(imagePath, ptr_size1);
1314     ASSERT_NE(imageBuf, nullptr);
1315     printf("==========OH_AI_TensorCreate==========\n");
1316     constexpr size_t create_shape_num = 4;
1317     int64_t create_shape[create_shape_num] = {1, 48, 48, 3};
1318     OH_AI_TensorHandle tensor = OH_AI_TensorCreate("data", OH_AI_DATATYPE_NUMBERTYPE_FLOAT32, create_shape,
1319                                            create_shape_num, imageBuf, size1);
1320     ASSERT_NE(tensor, nullptr);
1321     constexpr size_t data_len = 6;
1322     float data[data_len] = {1, 2, 3, 4, 5, 6};
1323     OH_AI_TensorSetData(tensor, data);
1324     const float *ret_data = static_cast<const float *>(OH_AI_TensorGetData(tensor));
1325     ASSERT_NE(ret_data, nullptr);
1326     printf("return data is:");
1327     for (size_t i = 0; i < data_len; i++) {
1328         ASSERT_EQ(ret_data[i], data[i]);
1329         printf("%f ", ret_data[i]);
1330     }
1331     printf("\n");
1332     delete[] imageBuf;
1333     OH_AI_TensorDestroy(&tensor);
1334 }
1335 
1336 // 正常场景：MSTensorGetElementNum,获取tensor元素
1337 HWTEST(MSLiteTest, OHOS_Tensor_Create_0013, Function | MediumTest | Level1) {
1338     printf("==========ReadFile==========\n");
1339     size_t size1;
1340     size_t *ptr_size1 = &size1;
1341     const char *imagePath = "/data/test/ml_face_isface.input";
1342     char *imageBuf = ReadFile(imagePath, ptr_size1);
1343     ASSERT_NE(imageBuf, nullptr);
1344     printf("==========OH_AI_TensorCreate==========\n");
1345     constexpr size_t create_shape_num = 4;
1346     int64_t create_shape[create_shape_num] = {1, 48, 48, 3};
1347     OH_AI_TensorHandle tensor = OH_AI_TensorCreate("data", OH_AI_DATATYPE_NUMBERTYPE_FLOAT32, create_shape,
1348                                            create_shape_num, imageBuf, size1);
1349     ASSERT_NE(tensor, nullptr);
1350     int64_t element_num = OH_AI_TensorGetElementNum(tensor);
1351     printf("Tensor name: %s, elements num: %" PRId64 ".\n", OH_AI_TensorGetName(tensor), element_num);
1352     ASSERT_EQ(element_num, 6912);
1353     delete[] imageBuf;
1354     OH_AI_TensorDestroy(&tensor);
1355 }
1356 
1357 // 正常场景：MSTensorGetDataSize,获取tensor大小
1358 HWTEST(MSLiteTest, OHOS_Tensor_Create_0014, Function | MediumTest | Level1) {
1359     printf("==========ReadFile==========\n");
1360     size_t size1;
1361     size_t *ptr_size1 = &size1;
1362     const char *imagePath = "/data/test/ml_face_isface.input";
1363     char *imageBuf = ReadFile(imagePath, ptr_size1);
1364     ASSERT_NE(imageBuf, nullptr);
1365     printf("==========OH_AI_TensorCreate==========\n");
1366     constexpr size_t create_shape_num = 4;
1367     int64_t create_shape[create_shape_num] = {1, 48, 48, 3};
1368     OH_AI_TensorHandle tensor = OH_AI_TensorCreate("data", OH_AI_DATATYPE_NUMBERTYPE_FLOAT32, create_shape,
1369                                            create_shape_num, imageBuf, size1);
1370     ASSERT_NE(tensor, nullptr);
1371     size_t data_size = OH_AI_TensorGetDataSize(tensor);
1372     printf("Tensor data size: %zu.\n", data_size);
1373     ASSERT_EQ(data_size, 6912 * sizeof(float));
1374     delete[] imageBuf;
1375     OH_AI_TensorDestroy(&tensor);
1376 }
1377 
1378 // 正常场景：MSTensorGetMutableData,获取tensor可变数据指针
1379 HWTEST(MSLiteTest, OHOS_Tensor_Create_0015, Function | MediumTest | Level1) {
1380     printf("==========ReadFile==========\n");
1381     size_t size1;
1382     size_t *ptr_size1 = &size1;
1383     const char *imagePath = "/data/test/ml_face_isface.input";
1384     char *imageBuf = ReadFile(imagePath, ptr_size1);
1385     ASSERT_NE(imageBuf, nullptr);
1386     printf("==========OH_AI_TensorCreate==========\n");
1387     constexpr size_t create_shape_num = 4;
1388     int64_t create_shape[create_shape_num] = {1, 48, 48, 3};
1389     OH_AI_TensorHandle tensor = OH_AI_TensorCreate("data", OH_AI_DATATYPE_NUMBERTYPE_FLOAT32, create_shape,
1390                                            create_shape_num, imageBuf, size1);
1391     ASSERT_NE(tensor, nullptr);
1392     float *input_data = reinterpret_cast<float *>(OH_AI_TensorGetMutableData(tensor));
1393     ASSERT_NE(input_data, nullptr);
1394     delete[] imageBuf;
1395     OH_AI_TensorDestroy(&tensor);
1396 }
1397 
1398 // 正常场景：MSTensorClone,拷贝tensor
1399 HWTEST(MSLiteTest, OHOS_Tensor_Create_0016, Function | MediumTest | Level1) {
1400     printf("==========ReadFile==========\n");
1401     size_t size1;
1402     size_t *ptr_size1 = &size1;
1403     const char *imagePath = "/data/test/ml_face_isface.input";
1404     char *imageBuf = ReadFile(imagePath, ptr_size1);
1405     ASSERT_NE(imageBuf, nullptr);
1406     printf("==========OH_AI_TensorCreate==========\n");
1407     constexpr size_t create_shape_num = 4;
1408     int64_t create_shape[create_shape_num] = {1, 48, 48, 3};
1409     OH_AI_TensorHandle tensor = OH_AI_TensorCreate("data", OH_AI_DATATYPE_NUMBERTYPE_FLOAT32, create_shape,
1410                                            create_shape_num, imageBuf, size1);
1411     ASSERT_NE(tensor, nullptr);
1412     OH_AI_TensorHandle clone = OH_AI_TensorClone(tensor);
1413     ASSERT_NE(clone, nullptr);
1414     ASSERT_EQ(strcmp(OH_AI_TensorGetName(clone), "data_duplicate"), 0);
1415     delete[] imageBuf;
1416     OH_AI_TensorDestroy(&tensor);
1417     OH_AI_TensorDestroy(&clone);
1418 }
1419 
1420 // 正常场景：单输入模型
1421 HWTEST(MSLiteTest, OHOS_Input_0001, Function | MediumTest | Level1) {
1422     printf("==========Init Context==========\n");
1423     OH_AI_ContextHandle context = OH_AI_ContextCreate();
1424     ASSERT_NE(context, nullptr);
1425     AddContextDeviceCPU(context);
1426     printf("==========Create model==========\n");
1427     OH_AI_ModelHandle model = OH_AI_ModelCreate();
1428     ASSERT_NE(model, nullptr);
1429     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
1430 }
1431 
1432 
1433 // 正常场景：量化模型
1434 HWTEST(MSLiteTest, OHOS_Input_0004, Function | MediumTest | Level1) {
1435     printf("==========Init Context==========\n");
1436     OH_AI_ContextHandle context = OH_AI_ContextCreate();
1437     ASSERT_NE(context, nullptr);
1438     AddContextDeviceCPU(context);
1439     printf("==========Create model==========\n");
1440     OH_AI_ModelHandle model = OH_AI_ModelCreate();
1441     ASSERT_NE(model, nullptr);
1442     ModelPredict(model, context, "ml_face_isface", {}, false, true, false);
1443 }
1444 
1445 // 正常场景：循环多次执行推理流程
1446 HWTEST(MSLiteTest, OHOS_Multiple_0001, Function | MediumTest | Level1) {
1447     for (size_t num = 0; num < 50; ++num) {
1448         Predict_CPU();
1449     }
1450 }
1451 
1452 // 正常场景：Model创建一次,Build一次，Predict多次
1453 HWTEST(MSLiteTest, OHOS_Multiple_0003, Function | MediumTest | Level1) {
1454     printf("==========Init Context==========\n");
1455     OH_AI_ContextHandle context = OH_AI_ContextCreate();
1456     ASSERT_NE(context, nullptr);
1457     AddContextDeviceCPU(context);
1458     printf("==========Create model==========\n");
1459     OH_AI_ModelHandle model = OH_AI_ModelCreate();
1460     ASSERT_NE(model, nullptr);
1461     printf("==========Build model==========\n");
1462     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_face_isface.ms", OH_AI_MODELTYPE_MINDIR, context);
1463     printf("==========build model return code:%d\n", ret);
1464     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
1465     printf("==========GetInputs==========\n");
1466     OH_AI_TensorHandleArray inputs = OH_AI_ModelGetInputs(model);
1467     ASSERT_NE(inputs.handle_list, nullptr);
1468     FillInputsData(inputs, "ml_face_isface", true);
1469     OH_AI_TensorHandleArray outputs;
1470     for (size_t i = 0; i < 50; ++i) {
1471         printf("==========Model Predict==========\n");
1472         OH_AI_Status predict_ret = OH_AI_ModelPredict(model, inputs, &outputs, nullptr, nullptr);
1473         ASSERT_EQ(predict_ret, OH_AI_STATUS_SUCCESS);
1474     }
1475     CompareResult(outputs, "ml_face_isface");
1476     OH_AI_ModelDestroy(&model);
1477 }
1478 
1479 // 正常场景：多次创建和销毁Model
1480 HWTEST(MSLiteTest, OHOS_Multiple_0004, Function | MediumTest | Level1) {
1481     for (size_t i = 0; i < 50; ++i) {
1482         printf("==========Init Context==========\n");
1483         OH_AI_ContextHandle context = OH_AI_ContextCreate();
1484         ASSERT_NE(context, nullptr);
1485         AddContextDeviceCPU(context);
1486         printf("==========Create model==========\n");
1487         OH_AI_ModelHandle model = OH_AI_ModelCreate();
1488         ASSERT_NE(model, nullptr);
1489         printf("==========Build model==========\n");
1490         OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_face_isface.ms", OH_AI_MODELTYPE_MINDIR, context);
1491         printf("==========build model return code:%d\n", ret);
1492         ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
1493         printf("==========Build model==========\n");
1494         OH_AI_ModelDestroy(&model);
1495     }
1496 }
1497 
1498 // 正常场景：两个模型都在CPU上并行推理
1499 HWTEST(MSLiteTest, OHOS_Parallel_0001, Function | MediumTest | Level1) {
1500     std::cout << "run start" << std::endl;
1501     std::thread t1(Predict_CPU);
1502     std::cout << "1111111111111" << std::endl;
1503     std::thread t2(Predict_CPU);
1504     std::cout << "2222222222222" << std::endl;
1505     t1.join();
1506     t2.join();
1507 }
1508 
1509 // 正常场景：r1.3转换的模型在r1.5上推理
1510 HWTEST(MSLiteTest, OHOS_Compatible_0001, Function | MediumTest | Level1) {
1511     printf("==========Init Context==========\n");
1512     OH_AI_ContextHandle context = OH_AI_ContextCreate();
1513     ASSERT_NE(context, nullptr);
1514     AddContextDeviceCPU(context);
1515     printf("==========Create model==========\n");
1516     OH_AI_ModelHandle model = OH_AI_ModelCreate();
1517     ASSERT_NE(model, nullptr);
1518     printf("==========Build model==========\n");
1519     OH_AI_Status ret = OH_AI_ModelBuildFromFile(model, "/data/test/ml_face_isface_r13.ms",
1520         OH_AI_MODELTYPE_MINDIR, context);
1521     printf("==========build model return code:%d\n", ret);
1522     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
1523     printf("==========GetInputs==========\n");
1524     OH_AI_TensorHandleArray inputs = OH_AI_ModelGetInputs(model);
1525     ASSERT_NE(inputs.handle_list, nullptr);
1526     FillInputsData(inputs, "ml_face_isface", true);
1527     printf("==========Model Predict==========\n");
1528     OH_AI_TensorHandleArray outputs;
1529     ret = OH_AI_ModelPredict(model, inputs, &outputs, nullptr, nullptr);
1530     ASSERT_EQ(ret, OH_AI_STATUS_SUCCESS);
1531     CompareResult(outputs, "ml_face_isface");
1532     OH_AI_ModelDestroy(&model);
1533 }