From 5638fb325841551a05c4c915c81036f4d0c5bc1b Mon Sep 17 00:00:00 2001 From: sunsuodong Date: Sun, 6 Feb 2022 18:19:01 -0800 Subject: [PATCH] fix ut Signed-off-by: sunsuodong --- build.sh | 2 + .../lite/test/ut/src/api/context_c_test.cc | 50 ++++++++-------- .../lite/test/ut/src/api/tensor_c_test.cc | 59 ++++++++++--------- 3 files changed, 57 insertions(+), 54 deletions(-) diff --git a/build.sh b/build.sh index d54432e709..d5c78d17b5 100755 --- a/build.sh +++ b/build.sh @@ -78,6 +78,8 @@ if [[ "X$COMPILE_LITE" = "Xon" ]]; then export ENABLE_VERBOSE export LITE_PLATFORM export LITE_ENABLE_AAR + export MSLITE_MINDDATA_IMPLEMENT=off + export MSLITE_ENABLE_TRAIN=off source mindspore/lite/build_lite.sh else mkdir -pv "${BUILD_PATH}/package/mindspore/lib" diff --git a/mindspore/lite/test/ut/src/api/context_c_test.cc b/mindspore/lite/test/ut/src/api/context_c_test.cc index 18ee04e43a..18fab61d3d 100644 --- a/mindspore/lite/test/ut/src/api/context_c_test.cc +++ b/mindspore/lite/test/ut/src/api/context_c_test.cc @@ -23,51 +23,51 @@ class ContextCTest : public mindspore::CommonTest { }; TEST_F(ContextCTest, common_test) { - MSDeviceInfoHandle npu_device_info = MSDeviceInfoCreate(kMSDeviceTypeKirinNPU); + OH_AI_DeviceInfoHandle npu_device_info = OH_AI_DeviceInfoCreate(OH_AI_DEVICETYPE_KIRIN_NPU); ASSERT_TRUE(npu_device_info != nullptr); - ASSERT_EQ(MSDeviceInfoGetDeviceType(npu_device_info), kMSDeviceTypeKirinNPU); + ASSERT_EQ(OH_AI_DeviceInfoGetDeviceType(npu_device_info), OH_AI_DEVICETYPE_KIRIN_NPU); - MSDeviceInfoSetProvider(npu_device_info, "vendor name"); - ASSERT_STREQ(MSDeviceInfoGetProvider(npu_device_info), "vendor name"); + OH_AI_DeviceInfoSetProvider(npu_device_info, "vendor name"); + ASSERT_STREQ(OH_AI_DeviceInfoGetProvider(npu_device_info), "vendor name"); - MSDeviceInfoSetProviderDevice(npu_device_info, "npu_a"); - ASSERT_STREQ(MSDeviceInfoGetProviderDevice(npu_device_info), "npu_a"); + OH_AI_DeviceInfoSetProviderDevice(npu_device_info, "npu_a"); + ASSERT_STREQ(OH_AI_DeviceInfoGetProviderDevice(npu_device_info), "npu_a"); - MSDeviceInfoSetFrequency(npu_device_info, 3); - ASSERT_EQ(MSDeviceInfoGetFrequency(npu_device_info), 3); + OH_AI_DeviceInfoSetFrequency(npu_device_info, 3); + ASSERT_EQ(OH_AI_DeviceInfoGetFrequency(npu_device_info), 3); - MSContextHandle context = MSContextCreate(); + OH_AI_ContextHandle context = OH_AI_ContextCreate(); ASSERT_TRUE(context != nullptr); - MSContextSetThreadNum(context, 4); - ASSERT_EQ(MSContextGetThreadNum(context), 4); + OH_AI_ContextSetThreadNum(context, 4); + ASSERT_EQ(OH_AI_ContextGetThreadNum(context), 4); - MSContextSetThreadAffinityMode(context, 2); - ASSERT_EQ(MSContextGetThreadAffinityMode(context), 2); + OH_AI_ContextSetThreadAffinityMode(context, 2); + ASSERT_EQ(OH_AI_ContextGetThreadAffinityMode(context), 2); constexpr size_t core_num = 4; int32_t core_list[core_num] = {1, 3, 2, 0}; - MSContextSetThreadAffinityCoreList(context, core_list, core_num); + OH_AI_ContextSetThreadAffinityCoreList(context, core_list, core_num); size_t ret_core_num; const int32_t *ret_core_list = nullptr; - ret_core_list = MSContextGetThreadAffinityCoreList(context, &ret_core_num); + ret_core_list = OH_AI_ContextGetThreadAffinityCoreList(context, &ret_core_num); ASSERT_EQ(ret_core_num, core_num); for (size_t i = 0; i < ret_core_num; i++) { ASSERT_EQ(ret_core_list[i], core_list[i]); } - MSContextSetEnableParallel(context, true); - ASSERT_EQ(MSContextGetEnableParallel(context), true); + OH_AI_ContextSetEnableParallel(context, true); + ASSERT_EQ(OH_AI_ContextGetEnableParallel(context), true); - MSDeviceInfoHandle cpu_device_info = MSDeviceInfoCreate(kMSDeviceTypeCPU); - MSDeviceInfoDestroy(&cpu_device_info); - cpu_device_info = MSDeviceInfoCreate(kMSDeviceTypeCPU); + OH_AI_DeviceInfoHandle cpu_device_info = OH_AI_DeviceInfoCreate(OH_AI_DEVICETYPE_CPU); + OH_AI_DeviceInfoDestroy(&cpu_device_info); + cpu_device_info = OH_AI_DeviceInfoCreate(OH_AI_DEVICETYPE_CPU); - MSDeviceInfoSetEnableFP16(cpu_device_info, true); - ASSERT_EQ(MSDeviceInfoGetEnableFP16(cpu_device_info), true); + OH_AI_DeviceInfoSetEnableFP16(cpu_device_info, true); + ASSERT_EQ(OH_AI_DeviceInfoGetEnableFP16(cpu_device_info), true); - MSContextAddDeviceInfo(context, cpu_device_info); - MSContextAddDeviceInfo(context, npu_device_info); - MSContextDestroy(&context); + OH_AI_ContextAddDeviceInfo(context, cpu_device_info); + OH_AI_ContextAddDeviceInfo(context, npu_device_info); + OH_AI_ContextDestroy(&context); } } // namespace mindspore diff --git a/mindspore/lite/test/ut/src/api/tensor_c_test.cc b/mindspore/lite/test/ut/src/api/tensor_c_test.cc index 4e7ef7c8ae..e8341dd98d 100644 --- a/mindspore/lite/test/ut/src/api/tensor_c_test.cc +++ b/mindspore/lite/test/ut/src/api/tensor_c_test.cc @@ -25,65 +25,66 @@ class TensorCTest : public mindspore::CommonTest { TEST_F(TensorCTest, common_test) { constexpr size_t shape_num = 2; int64_t shape[shape_num] = {2, 3}; - MSTensorHandle tensor = MSTensorCreate("name001", kMSDataTypeNumberTypeInt32, shape, shape_num, nullptr, 0); + OH_AI_TensorHandle tensor = + OH_AI_TensorCreate("name001", OH_AI_DATATYPE_NUMBERTYPE_INT32, shape, shape_num, nullptr, 0); ASSERT_TRUE(tensor != nullptr); - ASSERT_STREQ(MSTensorGetName(tensor), "name001"); - ASSERT_EQ(MSTensorGetDataType(tensor), kMSDataTypeNumberTypeInt32); + ASSERT_STREQ(OH_AI_TensorGetName(tensor), "name001"); + ASSERT_EQ(OH_AI_TensorGetDataType(tensor), OH_AI_DATATYPE_NUMBERTYPE_INT32); size_t ret_shape_num; - const int64_t *ret_shape = MSTensorGetShape(tensor, &ret_shape_num); + const int64_t *ret_shape = OH_AI_TensorGetShape(tensor, &ret_shape_num); ASSERT_EQ(ret_shape_num, shape_num); for (size_t i = 0; i < ret_shape_num; i++) { ASSERT_EQ(ret_shape[i], shape[i]); } - ASSERT_EQ(MSTensorGetElementNum(tensor), 6); - ASSERT_EQ(MSTensorGetDataSize(tensor), 6 * sizeof(int32_t)); - ASSERT_EQ(MSTensorGetData(tensor), nullptr); - ASSERT_TRUE(MSTensorGetMutableData(tensor) != nullptr); + ASSERT_EQ(OH_AI_TensorGetElementNum(tensor), 6); + ASSERT_EQ(OH_AI_TensorGetDataSize(tensor), 6 * sizeof(int32_t)); + ASSERT_EQ(OH_AI_TensorGetData(tensor), nullptr); + ASSERT_TRUE(OH_AI_TensorGetMutableData(tensor) != nullptr); - MSTensorSetName(tensor, "name002"); - ASSERT_STREQ(MSTensorGetName(tensor), "name002"); + OH_AI_TensorSetName(tensor, "name002"); + ASSERT_STREQ(OH_AI_TensorGetName(tensor), "name002"); - MSTensorSetDataType(tensor, kMSDataTypeNumberTypeFloat32); - ASSERT_EQ(MSTensorGetDataType(tensor), kMSDataTypeNumberTypeFloat32); + OH_AI_TensorSetDataType(tensor, OH_AI_DATATYPE_NUMBERTYPE_FLOAT32); + ASSERT_EQ(OH_AI_TensorGetDataType(tensor), OH_AI_DATATYPE_NUMBERTYPE_FLOAT32); constexpr size_t new_shape_num = 4; int64_t new_shape[new_shape_num] = {1, 2, 3, 1}; - MSTensorSetShape(tensor, new_shape, new_shape_num); + OH_AI_TensorSetShape(tensor, new_shape, new_shape_num); size_t new_ret_shape_num; - const int64_t *new_ret_shape = MSTensorGetShape(tensor, &new_ret_shape_num); + const int64_t *new_ret_shape = OH_AI_TensorGetShape(tensor, &new_ret_shape_num); ASSERT_EQ(new_ret_shape_num, new_shape_num); for (size_t i = 0; i < new_ret_shape_num; i++) { ASSERT_EQ(new_ret_shape[i], new_shape[i]); } - MSTensorSetFormat(tensor, kMSFormatNCHW); - ASSERT_EQ(MSTensorGetFormat(tensor), kMSFormatNCHW); + OH_AI_TensorSetFormat(tensor, OH_AI_FORMAT_NCHW); + ASSERT_EQ(OH_AI_TensorGetFormat(tensor), OH_AI_FORMAT_NCHW); constexpr size_t data_len = 6; - ASSERT_EQ(MSTensorGetElementNum(tensor), data_len); - ASSERT_EQ(MSTensorGetDataSize(tensor), data_len * sizeof(float)); + ASSERT_EQ(OH_AI_TensorGetElementNum(tensor), data_len); + ASSERT_EQ(OH_AI_TensorGetDataSize(tensor), data_len * sizeof(float)); float data[data_len] = {1, 2, 3, 4, 5, 6}; - MSTensorSetData(tensor, data); - const float *ret_data = static_cast(MSTensorGetData(tensor)); + OH_AI_TensorSetData(tensor, data); + const float *ret_data = static_cast(OH_AI_TensorGetData(tensor)); for (size_t i = 0; i < data_len; i++) { ASSERT_EQ(ret_data[i], data[i]); } - MSTensorHandle clone = MSTensorClone(tensor); + OH_AI_TensorHandle clone = OH_AI_TensorClone(tensor); ASSERT_TRUE(clone != nullptr); - ASSERT_STREQ(MSTensorGetName(clone), "name002_duplicate"); - ASSERT_EQ(MSTensorGetDataType(clone), kMSDataTypeNumberTypeFloat32); + ASSERT_STREQ(OH_AI_TensorGetName(clone), "name002_duplicate"); + ASSERT_EQ(OH_AI_TensorGetDataType(clone), OH_AI_DATATYPE_NUMBERTYPE_FLOAT32); size_t clone_shape_num; - const int64_t *clone_shape = MSTensorGetShape(clone, &clone_shape_num); + const int64_t *clone_shape = OH_AI_TensorGetShape(clone, &clone_shape_num); ASSERT_EQ(clone_shape_num, new_ret_shape_num); for (size_t i = 0; i < clone_shape_num; i++) { ASSERT_EQ(clone_shape[i], new_ret_shape[i]); } - ASSERT_EQ(MSTensorGetElementNum(clone), MSTensorGetElementNum(tensor)); - ASSERT_EQ(MSTensorGetDataSize(clone), MSTensorGetDataSize(tensor)); - ASSERT_TRUE(MSTensorGetData(clone) != MSTensorGetData(tensor)); + ASSERT_EQ(OH_AI_TensorGetElementNum(clone), OH_AI_TensorGetElementNum(tensor)); + ASSERT_EQ(OH_AI_TensorGetDataSize(clone), OH_AI_TensorGetDataSize(tensor)); + ASSERT_TRUE(OH_AI_TensorGetData(clone) != OH_AI_TensorGetData(tensor)); - MSTensorDestroy(&tensor); - MSTensorDestroy(&clone); + OH_AI_TensorDestroy(&tensor); + OH_AI_TensorDestroy(&clone); } } // namespace mindspore -- Gitee