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 <gtest/gtest.h> 17 18 #include "frameworks/native/transform.h" 19 #include "frameworks/native/memory_manager.h" 20 21 using namespace testing; 22 using namespace testing::ext; 23 using namespace OHOS::NeuralNetworkRuntime; 24 namespace OHOS { 25 namespace NeuralNetworkRuntime { 26 namespace UnitTest { 27 class TransformTestTest : public testing::Test { 28 public: 29 TransformTestTest() = default; 30 ~TransformTestTest() = default; 31 }; 32 33 /** 34 * @tc.name: transform_transhdidevicetype_001 35 * @tc.desc: Verify the TransHDIDeviceType function return OH_NN_CPU 36 * @tc.type: FUNC 37 */ 38 HWTEST_F(TransformTestTest, transform_transhdidevicetype_001, TestSize.Level0) 39 { 40 V1_0::DeviceType iDeviceType = V1_0::DeviceType::CPU; 41 OH_NN_DeviceType result = HDIToNN::TransHDIDeviceType(iDeviceType); 42 EXPECT_EQ(OH_NN_CPU, result); 43 } 44 45 /** 46 * @tc.name: transform_transhdidevicetype_002 47 * @tc.desc: Verify the TransHDIDeviceType function return OH_NN_GPU 48 * @tc.type: FUNC 49 */ 50 HWTEST_F(TransformTestTest, transform_transhdidevicetype_002, TestSize.Level0) 51 { 52 V1_0::DeviceType iDeviceType = V1_0::DeviceType::GPU; 53 OH_NN_DeviceType result = HDIToNN::TransHDIDeviceType(iDeviceType); 54 EXPECT_EQ(OH_NN_GPU, result); 55 } 56 57 /** 58 * @tc.name: transform_transhdidevicetype_003 59 * @tc.desc: Verify the TransHDIDeviceType function return OH_NN_ACCELERATOR 60 * @tc.type: FUNC 61 */ 62 HWTEST_F(TransformTestTest, transform_transhdidevicetype_003, TestSize.Level0) 63 { 64 V1_0::DeviceType iDeviceType = V1_0::DeviceType::ACCELERATOR; 65 OH_NN_DeviceType result = HDIToNN::TransHDIDeviceType(iDeviceType); 66 EXPECT_EQ(OH_NN_ACCELERATOR, result); 67 } 68 69 /** 70 * @tc.name: transform_transhdidevicetype_004 71 * @tc.desc: Verify the TransHDIDeviceType function return OH_NN_OTHERS 72 * @tc.type: FUNC 73 */ 74 HWTEST_F(TransformTestTest, transform_transhdidevicetype_004, TestSize.Level0) 75 { 76 V1_0::DeviceType iDeviceType = V1_0::DeviceType::OTHER; 77 OH_NN_DeviceType result = HDIToNN::TransHDIDeviceType(iDeviceType); 78 EXPECT_EQ(OH_NN_OTHERS, result); 79 } 80 81 /** 82 * @tc.name: transform_transhdidevicestatus_001 83 * @tc.desc: Verify the TransHDIDeviceStatus function return AVAILABLE 84 * @tc.type: FUNC 85 */ 86 HWTEST_F(TransformTestTest, transform_transhdidevicestatus_001, TestSize.Level0) 87 { 88 V1_0::DeviceStatus iDeviceStatus = V1_0::DeviceStatus::AVAILABLE; 89 DeviceStatus result = HDIToNN::TransHDIDeviceStatus(iDeviceStatus); 90 EXPECT_EQ(DeviceStatus::AVAILABLE, result); 91 } 92 93 /** 94 * @tc.name: transform_transhdidevicestatus_002 95 * @tc.desc: Verify the TransHDIDeviceStatus function return BUSY. 96 * @tc.type: FUNC 97 */ 98 HWTEST_F(TransformTestTest, transform_transhdidevicestatus_002, TestSize.Level0) 99 { 100 V1_0::DeviceStatus iDeviceStatus = V1_0::DeviceStatus::BUSY; 101 DeviceStatus result = HDIToNN::TransHDIDeviceStatus(iDeviceStatus); 102 EXPECT_EQ(DeviceStatus::BUSY, result); 103 } 104 105 /** 106 * @tc.name: transform_transhdidevicestatus_003 107 * @tc.desc: Verify the TransHDIDeviceStatus function return OFFLINE. 108 * @tc.type: FUNC 109 */ 110 HWTEST_F(TransformTestTest, transform_transhdidevicestatus_003, TestSize.Level0) 111 { 112 V1_0::DeviceStatus iDeviceStatus = V1_0::DeviceStatus::OFFLINE; 113 DeviceStatus result = HDIToNN::TransHDIDeviceStatus(iDeviceStatus); 114 EXPECT_EQ(DeviceStatus::OFFLINE, result); 115 } 116 117 /** 118 * @tc.name: transform_transhdidevicestatus_004 119 * @tc.desc: Verify the TransHDIDeviceStatus function return UNKNOWN. 120 * @tc.type: FUNC 121 */ 122 HWTEST_F(TransformTestTest, transform_transhdidevicestatus_004, TestSize.Level0) 123 { 124 V1_0::DeviceStatus iDeviceStatus = V1_0::DeviceStatus::UNKNOWN; 125 DeviceStatus result = HDIToNN::TransHDIDeviceStatus(iDeviceStatus); 126 EXPECT_EQ(DeviceStatus::UNKNOWN, result); 127 } 128 129 /** 130 * @tc.name: transform_transperformancemode_001 131 * @tc.desc: Verify the TransPerformanceMode function return PERFORMANCE_LOW. 132 * @tc.type: FUNC 133 */ 134 HWTEST_F(TransformTestTest, transform_transperformancemode_001, TestSize.Level0) 135 { 136 OH_NN_PerformanceMode mode = OH_NN_PERFORMANCE_LOW; 137 V1_0::PerformanceMode result = NNToHDI::TransPerformanceMode(mode); 138 EXPECT_EQ(V1_0::PerformanceMode::PERFORMANCE_LOW, result); 139 } 140 141 /** 142 * @tc.name: transform_transperformancemode_002 143 * @tc.desc: Verify the TransPerformanceMode function return PERFORMANCE_MEDIUM. 144 * @tc.type: FUNC 145 */ 146 HWTEST_F(TransformTestTest, transform_transperformancemode_002, TestSize.Level0) 147 { 148 OH_NN_PerformanceMode mode = OH_NN_PERFORMANCE_MEDIUM; 149 V1_0::PerformanceMode result = NNToHDI::TransPerformanceMode(mode); 150 EXPECT_EQ(V1_0::PerformanceMode::PERFORMANCE_MEDIUM, result); 151 } 152 153 /** 154 * @tc.name: transform_transperformancemode_003 155 * @tc.desc: Verify the TransPerformanceMode function return PERFORMANCE_HIGH. 156 * @tc.type: FUNC 157 */ 158 HWTEST_F(TransformTestTest, transform_transperformancemode_003, TestSize.Level0) 159 { 160 OH_NN_PerformanceMode mode = OH_NN_PERFORMANCE_HIGH; 161 V1_0::PerformanceMode result = NNToHDI::TransPerformanceMode(mode); 162 EXPECT_EQ(V1_0::PerformanceMode::PERFORMANCE_HIGH, result); 163 } 164 165 /** 166 * @tc.name: transform_transperformancemode_004 167 * @tc.desc: Verify the TransPerformanceMode function return PERFORMANCE_EXTREME. 168 * @tc.type: FUNC 169 */ 170 HWTEST_F(TransformTestTest, transform_transperformancemode_004, TestSize.Level0) 171 { 172 OH_NN_PerformanceMode mode = OH_NN_PERFORMANCE_EXTREME; 173 V1_0::PerformanceMode result = NNToHDI::TransPerformanceMode(mode); 174 EXPECT_EQ(V1_0::PerformanceMode::PERFORMANCE_EXTREME, result); 175 } 176 177 /** 178 * @tc.name: transform_transperformancemode_005 179 * @tc.desc: Verify the TransPerformanceMode function return PERFORMANCE_NONE. 180 * @tc.type: FUNC 181 */ 182 HWTEST_F(TransformTestTest, transform_transperformancemode_005, TestSize.Level0) 183 { 184 OH_NN_PerformanceMode mode = OH_NN_PERFORMANCE_NONE; 185 V1_0::PerformanceMode result = NNToHDI::TransPerformanceMode(mode); 186 EXPECT_EQ(V1_0::PerformanceMode::PERFORMANCE_NONE, result); 187 } 188 189 /** 190 * @tc.name: transform_transpriority_001 191 * @tc.desc: Verify the TransPriority function return PRIORITY_LOW. 192 * @tc.type: FUNC 193 */ 194 HWTEST_F(TransformTestTest, transform_transpriority_001, TestSize.Level0) 195 { 196 OH_NN_Priority priority = OH_NN_PRIORITY_LOW; 197 V1_0::Priority result = NNToHDI::TransPriority(priority); 198 EXPECT_EQ(V1_0::Priority::PRIORITY_LOW, result); 199 } 200 201 /** 202 * @tc.name: transform_transpriority_002 203 * @tc.desc: Verify the TransPriority function return PRIORITY_MEDIUM. 204 * @tc.type: FUNC 205 */ 206 HWTEST_F(TransformTestTest, transform_transpriority_002, TestSize.Level0) 207 { 208 OH_NN_Priority priority = OH_NN_PRIORITY_MEDIUM; 209 V1_0::Priority result = NNToHDI::TransPriority(priority); 210 EXPECT_EQ(V1_0::Priority::PRIORITY_MEDIUM, result); 211 } 212 213 /** 214 * @tc.name: transform_transpriority_003 215 * @tc.desc: Verify the TransPriority function return PRIORITY_HIGH. 216 * @tc.type: FUNC 217 */ 218 HWTEST_F(TransformTestTest, transform_transpriority_003, TestSize.Level0) 219 { 220 OH_NN_Priority priority = OH_NN_PRIORITY_HIGH; 221 V1_0::Priority result = NNToHDI::TransPriority(priority); 222 EXPECT_EQ(V1_0::Priority::PRIORITY_HIGH, result); 223 } 224 225 /** 226 * @tc.name: transform_transdatatype_001 227 * @tc.desc: Verify the TransDataType function return DATA_TYPE_BOOL. 228 * @tc.type: FUNC 229 */ 230 HWTEST_F(TransformTestTest, transform_transdatatype_001, TestSize.Level0) 231 { 232 OH_NN_DataType dataType = OH_NN_BOOL; 233 V1_0::DataType result = NNToHDI::TransDataType(dataType); 234 EXPECT_EQ(V1_0::DataType::DATA_TYPE_BOOL, result); 235 } 236 237 /** 238 * @tc.name: transform_transdatatype_002 239 * @tc.desc: Verify the TransDataType function return DATA_TYPE_INT8. 240 * @tc.type: FUNC 241 */ 242 HWTEST_F(TransformTestTest, transform_transdatatype_002, TestSize.Level0) 243 { 244 OH_NN_DataType dataType = OH_NN_INT8; 245 V1_0::DataType result = NNToHDI::TransDataType(dataType); 246 EXPECT_EQ(V1_0::DataType::DATA_TYPE_INT8, result); 247 } 248 249 /** 250 * @tc.name: transform_transdatatype_003 251 * @tc.desc: Verify the TransDataType function return DATA_TYPE_INT16. 252 * @tc.type: FUNC 253 */ 254 HWTEST_F(TransformTestTest, transform_transdatatype_003, TestSize.Level0) 255 { 256 OH_NN_DataType dataType = OH_NN_INT16; 257 V1_0::DataType result = NNToHDI::TransDataType(dataType); 258 EXPECT_EQ(V1_0::DataType::DATA_TYPE_INT16, result); 259 } 260 261 /** 262 * @tc.name: transform_transdatatype_004 263 * @tc.desc: Verify the TransDataType function return DATA_TYPE_INT32. 264 * @tc.type: FUNC 265 */ 266 HWTEST_F(TransformTestTest, transform_transdatatype_004, TestSize.Level0) 267 { 268 OH_NN_DataType dataType = OH_NN_INT32; 269 V1_0::DataType result = NNToHDI::TransDataType(dataType); 270 EXPECT_EQ(V1_0::DataType::DATA_TYPE_INT32, result); 271 } 272 273 /** 274 * @tc.name: transform_transdatatype_005 275 * @tc.desc: Verify the TransDataType function return DATA_TYPE_INT64. 276 * @tc.type: FUNC 277 */ 278 HWTEST_F(TransformTestTest, transform_transdatatype_005, TestSize.Level0) 279 { 280 OH_NN_DataType dataType = OH_NN_INT64; 281 V1_0::DataType result = NNToHDI::TransDataType(dataType); 282 EXPECT_EQ(V1_0::DataType::DATA_TYPE_INT64, result); 283 } 284 285 /** 286 * @tc.name: transform_transdatatype_006 287 * @tc.desc: Verify the TransDataType function return DATA_TYPE_UINT8. 288 * @tc.type: FUNC 289 */ 290 HWTEST_F(TransformTestTest, transform_transdatatype_006, TestSize.Level0) 291 { 292 OH_NN_DataType dataType = OH_NN_UINT8; 293 V1_0::DataType result = NNToHDI::TransDataType(dataType); 294 EXPECT_EQ(V1_0::DataType::DATA_TYPE_UINT8, result); 295 } 296 297 /** 298 * @tc.name: transform_transdatatype_007 299 * @tc.desc: Verify the TransDataType function return DATA_TYPE_UINT16. 300 * @tc.type: FUNC 301 */ 302 HWTEST_F(TransformTestTest, transform_transdatatype_007, TestSize.Level0) 303 { 304 OH_NN_DataType dataType = OH_NN_UINT16; 305 V1_0::DataType result = NNToHDI::TransDataType(dataType); 306 EXPECT_EQ(V1_0::DataType::DATA_TYPE_UINT16, result); 307 } 308 309 /** 310 * @tc.name: transform_transdatatype_008 311 * @tc.desc: Verify the TransDataType function return DATA_TYPE_UINT32. 312 * @tc.type: FUNC 313 */ 314 HWTEST_F(TransformTestTest, transform_transdatatype_008, TestSize.Level0) 315 { 316 OH_NN_DataType dataType = OH_NN_UINT32; 317 V1_0::DataType result = NNToHDI::TransDataType(dataType); 318 EXPECT_EQ(V1_0::DataType::DATA_TYPE_UINT32, result); 319 } 320 321 /** 322 * @tc.name: transform_transdatatype_009 323 * @tc.desc: Verify the TransDataType function return DATA_TYPE_UINT64. 324 * @tc.type: FUNC 325 */ 326 HWTEST_F(TransformTestTest, transform_transdatatype_009, TestSize.Level0) 327 { 328 OH_NN_DataType dataType = OH_NN_UINT64; 329 V1_0::DataType result = NNToHDI::TransDataType(dataType); 330 EXPECT_EQ(V1_0::DataType::DATA_TYPE_UINT64, result); 331 } 332 333 /** 334 * @tc.name: transform_transdatatype_010 335 * @tc.desc: Verify the TransDataType function return DATA_TYPE_FLOAT16. 336 * @tc.type: FUNC 337 */ 338 HWTEST_F(TransformTestTest, transform_transdatatype_010, TestSize.Level0) 339 { 340 OH_NN_DataType dataType = OH_NN_FLOAT16; 341 V1_0::DataType result = NNToHDI::TransDataType(dataType); 342 EXPECT_EQ(V1_0::DataType::DATA_TYPE_FLOAT16, result); 343 } 344 345 /** 346 * @tc.name: transform_transdatatype_011 347 * @tc.desc: Verify the TransDataType function return DATA_TYPE_FLOAT32. 348 * @tc.type: FUNC 349 */ 350 HWTEST_F(TransformTestTest, transform_transdatatype_011, TestSize.Level0) 351 { 352 OH_NN_DataType dataType = OH_NN_FLOAT32; 353 V1_0::DataType result = NNToHDI::TransDataType(dataType); 354 EXPECT_EQ(V1_0::DataType::DATA_TYPE_FLOAT32, result); 355 } 356 357 /** 358 * @tc.name: transform_transdatatype_012 359 * @tc.desc: Verify the TransDataType function return DATA_TYPE_UNKNOWN. 360 * @tc.type: FUNC 361 */ 362 HWTEST_F(TransformTestTest, transform_transdatatype_012, TestSize.Level0) 363 { 364 OH_NN_DataType dataType = OH_NN_UNKNOWN; 365 V1_0::DataType result = NNToHDI::TransDataType(dataType); 366 EXPECT_EQ(V1_0::DataType::DATA_TYPE_UNKNOWN, result); 367 } 368 369 /** 370 * @tc.name: transform_transdatatype_013 371 * @tc.desc: Verify the TransDataType function return DATA_TYPE_FLOAT64. 372 * @tc.type: FUNC 373 */ 374 HWTEST_F(TransformTestTest, transform_transdatatype_013, TestSize.Level0) 375 { 376 OH_NN_DataType dataType = OH_NN_FLOAT64; 377 V1_0::DataType result = NNToHDI::TransDataType(dataType); 378 EXPECT_EQ(V1_0::DataType::DATA_TYPE_FLOAT64, result); 379 } 380 381 /** 382 * @tc.name: transform_transformat_001 383 * @tc.desc: Verify the TransFormat function return FORMAT_NCHW. 384 * @tc.type: FUNC 385 */ 386 HWTEST_F(TransformTestTest, transform_transformat_001, TestSize.Level0) 387 { 388 OH_NN_Format format = OH_NN_FORMAT_NCHW; 389 V1_0::Format result = NNToHDI::TransFormat(format); 390 EXPECT_EQ(V1_0::Format::FORMAT_NCHW, result); 391 } 392 393 /** 394 * @tc.name: transform_transformat_002 395 * @tc.desc: Verify the TransFormat function return FORMAT_NHWC. 396 * @tc.type: FUNC 397 */ 398 HWTEST_F(TransformTestTest, transform_transformat_002, TestSize.Level0) 399 { 400 OH_NN_Format format = OH_NN_FORMAT_NHWC; 401 V1_0::Format result = NNToHDI::TransFormat(format); 402 EXPECT_EQ(V1_0::Format::FORMAT_NHWC, result); 403 } 404 405 /** 406 * @tc.name: transform_transformat_003 407 * @tc.desc: Verify the TransFormat function return FORMAT_NONE. 408 * @tc.type: FUNC 409 */ 410 HWTEST_F(TransformTestTest, transform_transformat_003, TestSize.Level0) 411 { 412 OH_NN_Format format = OH_NN_FORMAT_NONE; 413 V1_0::Format result = NNToHDI::TransFormat(format); 414 EXPECT_EQ(V1_0::Format::FORMAT_NONE, result); 415 } 416 417 /** 418 * @tc.name: transform_transiotensor_001 419 * @tc.desc: Verify the TransIOTensor function return int8 420 * @tc.type: FUNC 421 */ 422 HWTEST_F(TransformTestTest, transform_transiotensor_001, TestSize.Level0) 423 { 424 IOTensor tensor; 425 tensor.dataType = OH_NN_INT8; 426 V1_0::IOTensor result = NNToHDI::TransIOTensor(tensor); 427 EXPECT_EQ(V1_0::DataType::DATA_TYPE_INT8, result.dataType); 428 } 429 430 /** 431 * @tc.name: transform_gettypesize_001 432 * @tc.desc: Verify the TransIOTensor function return 1. 433 * @tc.type: FUNC 434 */ 435 HWTEST_F(TransformTestTest, transform_gettypesize_001, TestSize.Level0) 436 { 437 OH_NN_DataType dataType = OH_NN_BOOL; 438 uint32_t result = GetTypeSize(dataType); 439 EXPECT_EQ(static_cast<uint32_t>(1), result); 440 } 441 442 /** 443 * @tc.name: transform_gettypesize_002 444 * @tc.desc: Verify the TransIOTensor function return 2. 445 * @tc.type: FUNC 446 */ 447 HWTEST_F(TransformTestTest, transform_gettypesize_002, TestSize.Level0) 448 { 449 OH_NN_DataType dataType = OH_NN_INT16; 450 uint32_t result = GetTypeSize(dataType); 451 EXPECT_EQ(static_cast<uint32_t>(2), result); 452 } 453 454 /** 455 * @tc.name: transform_gettypesize_003 456 * @tc.desc: Verify the TransIOTensor function return 4. 457 * @tc.type: FUNC 458 */ 459 HWTEST_F(TransformTestTest, transform_gettypesize_003, TestSize.Level0) 460 { 461 OH_NN_DataType dataType = OH_NN_INT32; 462 uint32_t result = GetTypeSize(dataType); 463 EXPECT_EQ(static_cast<uint32_t>(4), result); 464 } 465 466 /** 467 * @tc.name: transform_gettypesize_004 468 * @tc.desc: Verify the TransIOTensor function return 8. 469 * @tc.type: FUNC 470 */ 471 HWTEST_F(TransformTestTest, transform_gettypesize_004, TestSize.Level0) 472 { 473 OH_NN_DataType dataType = OH_NN_INT64; 474 uint32_t result = GetTypeSize(dataType); 475 EXPECT_EQ(static_cast<uint32_t>(8), result); 476 } 477 478 /** 479 * @tc.name: transform_gettypesize_005 480 * @tc.desc: Verify the TransIOTensor function return 0. 481 * @tc.type: FUNC 482 */ 483 HWTEST_F(TransformTestTest, transform_gettypesize_005, TestSize.Level0) 484 { 485 OH_NN_DataType dataType = OH_NN_UNKNOWN; 486 uint32_t result = GetTypeSize(dataType); 487 EXPECT_EQ(static_cast<uint32_t>(0), result); 488 } 489 490 /** 491 * @tc.name: transform_nntoms_transformdatatype_001 492 * @tc.desc: Verify the TransIOTensor function return DATA_TYPE_BOOL. 493 * @tc.type: FUNC 494 */ 495 HWTEST_F(TransformTestTest, transform_nntoms_transformdatatype_001, TestSize.Level0) 496 { 497 OH_NN_DataType dataType = OH_NN_BOOL; 498 mindspore::lite::DataType result = NNToMS::TransformDataType(dataType); 499 EXPECT_EQ(mindspore::lite::DATA_TYPE_BOOL, result); 500 } 501 502 /** 503 * @tc.name: transform_nntoms_transformdatatype_002 504 * @tc.desc: Verify the TransDataType function return DATA_TYPE_INT8. 505 * @tc.type: FUNC 506 */ 507 HWTEST_F(TransformTestTest, transform_nntoms_transformdatatype_002, TestSize.Level0) 508 { 509 OH_NN_DataType dataType = OH_NN_INT8; 510 mindspore::lite::DataType result = NNToMS::TransformDataType(dataType); 511 EXPECT_EQ(mindspore::lite::DATA_TYPE_INT8, result); 512 } 513 514 /** 515 * @tc.name: transform_nntoms_transformdatatype_003 516 * @tc.desc: Verify the TransDataType function return DATA_TYPE_INT16. 517 * @tc.type: FUNC 518 */ 519 HWTEST_F(TransformTestTest, transform_nntoms_transformdatatype_003, TestSize.Level0) 520 { 521 OH_NN_DataType dataType = OH_NN_INT16; 522 mindspore::lite::DataType result = NNToMS::TransformDataType(dataType); 523 EXPECT_EQ(mindspore::lite::DATA_TYPE_INT16, result); 524 } 525 526 /** 527 * @tc.name: transform_nntoms_transformdatatype_004 528 * @tc.desc: Verify the TransDataType function return DATA_TYPE_INT32. 529 * @tc.type: FUNC 530 */ 531 HWTEST_F(TransformTestTest, transform_nntoms_transformdatatype_004, TestSize.Level0) 532 { 533 OH_NN_DataType dataType = OH_NN_INT32; 534 mindspore::lite::DataType result = NNToMS::TransformDataType(dataType); 535 EXPECT_EQ(mindspore::lite::DATA_TYPE_INT32, result); 536 } 537 538 /** 539 * @tc.name: transform_nntoms_transformdatatype_005 540 * @tc.desc: Verify the TransDataType function return DATA_TYPE_INT64. 541 * @tc.type: FUNC 542 */ 543 HWTEST_F(TransformTestTest, transform_nntoms_transformdatatype_005, TestSize.Level0) 544 { 545 OH_NN_DataType dataType = OH_NN_INT64; 546 mindspore::lite::DataType result = NNToMS::TransformDataType(dataType); 547 EXPECT_EQ(mindspore::lite::DATA_TYPE_INT64, result); 548 } 549 550 /** 551 * @tc.name: transform_nntoms_transformdatatype_006 552 * @tc.desc: Verify the TransDataType function return DATA_TYPE_UINT8. 553 * @tc.type: FUNC 554 */ 555 HWTEST_F(TransformTestTest, transform_nntoms_transformdatatype_006, TestSize.Level0) 556 { 557 OH_NN_DataType dataType = OH_NN_UINT8; 558 mindspore::lite::DataType result = NNToMS::TransformDataType(dataType); 559 EXPECT_EQ(mindspore::lite::DATA_TYPE_UINT8, result); 560 } 561 562 /** 563 * @tc.name: transform_nntoms_transformdatatype_007 564 * @tc.desc: Verify the TransDataType function return DATA_TYPE_UINT16. 565 * @tc.type: FUNC 566 */ 567 HWTEST_F(TransformTestTest, transform_nntoms_transformdatatype_007, TestSize.Level0) 568 { 569 OH_NN_DataType dataType = OH_NN_UINT16; 570 mindspore::lite::DataType result = NNToMS::TransformDataType(dataType); 571 EXPECT_EQ(mindspore::lite::DATA_TYPE_UINT16, result); 572 } 573 574 /** 575 * @tc.name: transform_nntoms_transformdatatype_008 576 * @tc.desc: Verify the TransDataType function return DATA_TYPE_UINT32. 577 * @tc.type: FUNC 578 */ 579 HWTEST_F(TransformTestTest, transform_nntoms_transformdatatype_008, TestSize.Level0) 580 { 581 OH_NN_DataType dataType = OH_NN_UINT32; 582 mindspore::lite::DataType result = NNToMS::TransformDataType(dataType); 583 EXPECT_EQ(mindspore::lite::DATA_TYPE_UINT32, result); 584 } 585 586 /** 587 * @tc.name: transform_nntoms_transformdatatype_009 588 * @tc.desc: Verify the TransDataType function return DATA_TYPE_UINT64. 589 * @tc.type: FUNC 590 */ 591 HWTEST_F(TransformTestTest, transform_nntoms_transformdatatype_009, TestSize.Level0) 592 { 593 OH_NN_DataType dataType = OH_NN_UINT64; 594 mindspore::lite::DataType result = NNToMS::TransformDataType(dataType); 595 EXPECT_EQ(mindspore::lite::DATA_TYPE_UINT64, result); 596 } 597 598 /** 599 * @tc.name: transform_nntoms_transformdatatype_010 600 * @tc.desc: Verify the TransDataType function return DATA_TYPE_FLOAT16. 601 * @tc.type: FUNC 602 */ 603 HWTEST_F(TransformTestTest, transform_nntoms_transformdatatype_010, TestSize.Level0) 604 { 605 OH_NN_DataType dataType = OH_NN_FLOAT16; 606 mindspore::lite::DataType result = NNToMS::TransformDataType(dataType); 607 EXPECT_EQ(mindspore::lite::DATA_TYPE_FLOAT16, result); 608 } 609 610 /** 611 * @tc.name: transform_nntoms_transformdatatype_011 612 * @tc.desc: Verify the TransDataType function return DATA_TYPE_FLOAT32. 613 * @tc.type: FUNC 614 */ 615 HWTEST_F(TransformTestTest, transform_nntoms_transformdatatype_011, TestSize.Level0) 616 { 617 OH_NN_DataType dataType = OH_NN_FLOAT32; 618 mindspore::lite::DataType result = NNToMS::TransformDataType(dataType); 619 EXPECT_EQ(mindspore::lite::DATA_TYPE_FLOAT32, result); 620 } 621 622 /** 623 * @tc.name: transform_nntoms_transformdatatype_012 624 * @tc.desc: Verify the TransDataType function return DATA_TYPE_UNKNOWN. 625 * @tc.type: FUNC 626 */ 627 HWTEST_F(TransformTestTest, transform_nntoms_transformdatatype_012, TestSize.Level0) 628 { 629 OH_NN_DataType dataType = OH_NN_UNKNOWN; 630 mindspore::lite::DataType result = NNToMS::TransformDataType(dataType); 631 EXPECT_EQ(mindspore::lite::DATA_TYPE_UNKNOWN, result); 632 } 633 634 /** 635 * @tc.name: transform_nntoms_transformdatatype_013 636 * @tc.desc: Verify the TransDataType function return DATA_TYPE_FLOAT64 637 * @tc.type: FUNC 638 */ 639 HWTEST_F(TransformTestTest, transform_nntoms_transformdatatype_013, TestSize.Level0) 640 { 641 OH_NN_DataType dataType = OH_NN_FLOAT64; 642 mindspore::lite::DataType result = NNToMS::TransformDataType(dataType); 643 EXPECT_EQ(mindspore::lite::DATA_TYPE_FLOAT64, result); 644 } 645 646 /** 647 * @tc.name: transform_nntoms_transformformat_001 648 * @tc.desc: Verify the TransFormat function return FORMAT_NCHW. 649 * @tc.type: FUNC 650 */ 651 HWTEST_F(TransformTestTest, transform_nntoms_transformformat_001, TestSize.Level0) 652 { 653 OH_NN_Format format = OH_NN_FORMAT_NCHW; 654 mindspore::lite::Format result = NNToMS::TransformFormat(format); 655 EXPECT_EQ(mindspore::lite::FORMAT_NCHW, result); 656 } 657 658 /** 659 * @tc.name: transform_nntoms_transformformat_002 660 * @tc.desc: Verify the TransFormat function return FORMAT_NHWC. 661 * @tc.type: FUNC 662 */ 663 HWTEST_F(TransformTestTest, transform_nntoms_transformformat_002, TestSize.Level0) 664 { 665 OH_NN_Format format = OH_NN_FORMAT_NHWC; 666 mindspore::lite::Format result = NNToMS::TransformFormat(format); 667 EXPECT_EQ(mindspore::lite::FORMAT_NHWC, result); 668 } 669 670 /** 671 * @tc.name: transform_nntoms_transformformat_003 672 * @tc.desc: Verify the TransFormat function return FORMAT_NHWC. 673 * @tc.type: FUNC 674 */ 675 HWTEST_F(TransformTestTest, transform_nntoms_transformformat_003, TestSize.Level0) 676 { 677 OH_NN_Format format = OH_NN_FORMAT_NONE; 678 mindspore::lite::Format result = NNToMS::TransformFormat(format); 679 EXPECT_EQ(mindspore::lite::FORMAT_NHWC, result); 680 } 681 682 /** 683 * @tc.name: transform_nntoms_transformfusiontype_001 684 * @tc.desc: Verify the TransFormat function return ACTIVATION_TYPE_NO_ACTIVATION. 685 * @tc.type: FUNC 686 */ 687 HWTEST_F(TransformTestTest, transform_nntoms_transformfusiontype_001, TestSize.Level0) 688 { 689 OH_NN_FuseType type = OH_NN_FUSED_NONE; 690 mindspore::lite::ActivationType result = NNToMS::TransfromFusionType(type); 691 EXPECT_EQ(mindspore::lite::ACTIVATION_TYPE_NO_ACTIVATION, result); 692 } 693 694 /** 695 * @tc.name: transform_nntoms_transformfusiontype_002 696 * @tc.desc: Verify the TransFormat function return ACTIVATION_TYPE_RELU. 697 * @tc.type: FUNC 698 */ 699 HWTEST_F(TransformTestTest, transform_nntoms_transformfusiontype_002, TestSize.Level0) 700 { 701 OH_NN_FuseType type = OH_NN_FUSED_RELU; 702 mindspore::lite::ActivationType result = NNToMS::TransfromFusionType(type); 703 EXPECT_EQ(mindspore::lite::ACTIVATION_TYPE_RELU, result); 704 } 705 706 /** 707 * @tc.name: transform_nntoms_transformfusiontype_003 708 * @tc.desc: Verify the TransFormat function return ACTIVATION_TYPE_RELU6. 709 * @tc.type: FUNC 710 */ 711 HWTEST_F(TransformTestTest, transform_nntoms_transformfusiontype_003, TestSize.Level0) 712 { 713 OH_NN_FuseType type = OH_NN_FUSED_RELU6; 714 mindspore::lite::ActivationType result = NNToMS::TransfromFusionType(type); 715 EXPECT_EQ(mindspore::lite::ACTIVATION_TYPE_RELU6, result); 716 } 717 718 /** 719 * @tc.name: transform_nntoms_transformquanttype_001 720 * @tc.desc: Verify the TransFormat function return QUANT_TYPE_NONE. 721 * @tc.type: FUNC 722 */ 723 HWTEST_F(TransformTestTest, transform_nntoms_transformquanttype_001, TestSize.Level0) 724 { 725 OHOS::NeuralNetworkRuntime::Ops::OpsQuantType type = OHOS::NeuralNetworkRuntime::Ops::OpsQuantType::QUANT_NONE; 726 mindspore::lite::QuantType result = NNToMS::TransformQuantType(type); 727 EXPECT_EQ(mindspore::lite::QUANT_TYPE_NONE, result); 728 } 729 730 /** 731 * @tc.name: transform_nntoms_transformquanttype_002 732 * @tc.desc: Verify the TransFormat function return QUANT_TYPE_ALL. 733 * @tc.type: FUNC 734 */ 735 HWTEST_F(TransformTestTest, transform_nntoms_transformquanttype_002, TestSize.Level0) 736 { 737 OHOS::NeuralNetworkRuntime::Ops::OpsQuantType type = OHOS::NeuralNetworkRuntime::Ops::OpsQuantType::QUANT_ALL; 738 mindspore::lite::QuantType result = NNToMS::TransformQuantType(type); 739 EXPECT_EQ(mindspore::lite::QUANT_TYPE_ALL, result); 740 } 741 742 743 /** 744 * @tc.name: transform_mstonn_transformdatatype_001 745 * @tc.desc: Verify the TransIOTensor function return OH_NN_BOOL. 746 * @tc.type: FUNC 747 */ 748 HWTEST_F(TransformTestTest, transform_mstonn_transformdatatype_001, TestSize.Level0) 749 { 750 mindspore::lite::DataType dataType = mindspore::lite::DATA_TYPE_BOOL; 751 OH_NN_DataType result = MSToNN::TransformDataType(dataType); 752 EXPECT_EQ(OH_NN_BOOL, result); 753 } 754 755 /** 756 * @tc.name: transform_mstonn_transformdatatype_002 757 * @tc.desc: Verify the TransDataType function return OH_NN_INT8. 758 * @tc.type: FUNC 759 */ 760 HWTEST_F(TransformTestTest, transform_mstonn_transformdatatype_002, TestSize.Level0) 761 { 762 mindspore::lite::DataType dataType = mindspore::lite::DATA_TYPE_INT8; 763 OH_NN_DataType result = MSToNN::TransformDataType(dataType); 764 EXPECT_EQ(OH_NN_INT8, result); 765 } 766 767 /** 768 * @tc.name: transform_mstonn_transformdatatype_003 769 * @tc.desc: Verify the TransDataType function return OH_NN_INT16. 770 * @tc.type: FUNC 771 */ 772 HWTEST_F(TransformTestTest, transform_mstonn_transformdatatype_003, TestSize.Level0) 773 { 774 mindspore::lite::DataType dataType = mindspore::lite::DATA_TYPE_INT16; 775 OH_NN_DataType result = MSToNN::TransformDataType(dataType); 776 EXPECT_EQ(OH_NN_INT16, result); 777 } 778 779 /** 780 * @tc.name: transform_mstonn_transformdatatype_004 781 * @tc.desc: Verify the TransDataType function return OH_NN_INT32. 782 * @tc.type: FUNC 783 */ 784 HWTEST_F(TransformTestTest, transform_mstonn_transformdatatype_004, TestSize.Level0) 785 { 786 mindspore::lite::DataType dataType = mindspore::lite::DATA_TYPE_INT32; 787 OH_NN_DataType result = MSToNN::TransformDataType(dataType); 788 EXPECT_EQ(OH_NN_INT32, result); 789 } 790 791 /** 792 * @tc.name: transform_mstonn_transformdatatype_005 793 * @tc.desc: Verify the TransDataType function return OH_NN_INT64. 794 * @tc.type: FUNC 795 */ 796 HWTEST_F(TransformTestTest, transform_mstonn_transformdatatype_005, TestSize.Level0) 797 { 798 mindspore::lite::DataType dataType = mindspore::lite::DATA_TYPE_INT64; 799 OH_NN_DataType result = MSToNN::TransformDataType(dataType); 800 EXPECT_EQ(OH_NN_INT64, result); 801 } 802 803 /** 804 * @tc.name: transform_mstonn_transformdatatype_006 805 * @tc.desc: Verify the TransDataType function return OH_NN_UINT8. 806 * @tc.type: FUNC 807 */ 808 HWTEST_F(TransformTestTest, transform_mstonn_transformdatatype_006, TestSize.Level0) 809 { 810 mindspore::lite::DataType dataType = mindspore::lite::DATA_TYPE_UINT8; 811 OH_NN_DataType result = MSToNN::TransformDataType(dataType); 812 EXPECT_EQ(OH_NN_UINT8, result); 813 } 814 815 /** 816 * @tc.name: transform_mstonn_transformdatatype_007 817 * @tc.desc: Verify the TransDataType function return OH_NN_UINT16. 818 * @tc.type: FUNC 819 */ 820 HWTEST_F(TransformTestTest, transform_mstonn_transformdatatype_007, TestSize.Level0) 821 { 822 mindspore::lite::DataType dataType = mindspore::lite::DATA_TYPE_UINT16; 823 OH_NN_DataType result = MSToNN::TransformDataType(dataType); 824 EXPECT_EQ(OH_NN_UINT16, result); 825 } 826 827 /** 828 * @tc.name: transform_mstonn_transformdatatype_008 829 * @tc.desc: Verify the TransDataType function return OH_NN_UINT32. 830 * @tc.type: FUNC 831 */ 832 HWTEST_F(TransformTestTest, transform_mstonn_transformdatatype_008, TestSize.Level0) 833 { 834 mindspore::lite::DataType dataType = mindspore::lite::DATA_TYPE_UINT32; 835 OH_NN_DataType result = MSToNN::TransformDataType(dataType); 836 EXPECT_EQ(OH_NN_UINT32, result); 837 } 838 839 /** 840 * @tc.name: transform_mstonn_transformdatatype_009 841 * @tc.desc: Verify the TransDataType function return OH_NN_UINT64. 842 * @tc.type: FUNC 843 */ 844 HWTEST_F(TransformTestTest, transform_mstonn_transformdatatype_009, TestSize.Level0) 845 { 846 mindspore::lite::DataType dataType = mindspore::lite::DATA_TYPE_UINT64; 847 OH_NN_DataType result = MSToNN::TransformDataType(dataType); 848 EXPECT_EQ(OH_NN_UINT64, result); 849 } 850 851 /** 852 * @tc.name: transform_mstonn_transformdatatype_010 853 * @tc.desc: Verify the TransDataType function return OH_NN_FLOAT16 854 * @tc.type: FUNC 855 */ 856 HWTEST_F(TransformTestTest, transform_mstonn_transformdatatype_010, TestSize.Level0) 857 { 858 mindspore::lite::DataType dataType = mindspore::lite::DATA_TYPE_FLOAT16; 859 OH_NN_DataType result = MSToNN::TransformDataType(dataType); 860 EXPECT_EQ(OH_NN_FLOAT16, result); 861 } 862 863 /** 864 * @tc.name: transform_mstonn_transformdatatype_011 865 * @tc.desc: Verify the TransDataType function return OH_NN_FLOAT32. 866 * @tc.type: FUNC 867 */ 868 HWTEST_F(TransformTestTest, transform_mstonn_transformdatatype_011, TestSize.Level0) 869 { 870 mindspore::lite::DataType dataType = mindspore::lite::DATA_TYPE_FLOAT32; 871 OH_NN_DataType result = MSToNN::TransformDataType(dataType); 872 EXPECT_EQ(OH_NN_FLOAT32, result); 873 } 874 875 /** 876 * @tc.name: transform_mstonn_transformdatatype_012 877 * @tc.desc: Verify the TransDataType function return OH_NN_UNKNOWN. 878 * @tc.type: FUNC 879 */ 880 HWTEST_F(TransformTestTest, transform_mstonn_transformdatatype_012, TestSize.Level0) 881 { 882 mindspore::lite::DataType dataType = mindspore::lite::DATA_TYPE_UNKNOWN; 883 OH_NN_DataType result = MSToNN::TransformDataType(dataType); 884 EXPECT_EQ(OH_NN_UNKNOWN, result); 885 } 886 887 /** 888 * @tc.name: transform_mstonn_transformdatatype_013 889 * @tc.desc: Verify the TransDataType function return DATA_TYPE_FLOAT64 890 * @tc.type: FUNC 891 */ 892 HWTEST_F(TransformTestTest, transform_mstonn_transformdatatype_013, TestSize.Level0) 893 { 894 mindspore::lite::DataType dataType = mindspore::lite::DATA_TYPE_FLOAT64; 895 OH_NN_DataType result = MSToNN::TransformDataType(dataType); 896 EXPECT_EQ(OH_NN_FLOAT64, result); 897 } 898 899 /** 900 * @tc.name: transform_mstonn_transformquantparams_001 901 * @tc.desc: Verify the TransformQuantParams function. 902 * @tc.type: FUNC 903 */ 904 HWTEST_F(TransformTestTest, transform_mstonn_transformquantparams_001, TestSize.Level0) 905 { 906 std::vector<mindspore::lite::QuantParam> msQuantParams = {{1, 1.0, 8}}; 907 std::vector<QuantParam> result = MSToNN::TransformQuantParams(msQuantParams); 908 EXPECT_EQ(msQuantParams.size(), result.size()); 909 } 910 } // namespace UnitTest 911 } // namespace NeuralNetworkRuntime 912 } // namespace OHOS 913