1 /* 2 * Copyright (c) 2024 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 <vector> 17 #include <string> 18 #include <iostream> 19 #include "nncore_utils.h" 20 21 using namespace testing::ext; 22 using namespace OHOS::NeuralNetworkRuntime::Test; 23 class ExpTest : public testing::Test {}; 24 25 struct ExpModel1 { 26 const std::vector<int32_t> tensor_shape = {3, 3}; 27 float baseValue = 1; 28 float scaleValue = 1.5; 29 float shiftValue = 1; 30 float inputValue[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; 31 float outputValue[3][3] = {0}; 32 33 OHNNOperandTest input = {OH_NN_FLOAT32, OH_NN_TENSOR, tensor_shape, inputValue, 9*sizeof(float)}; 34 OHNNOperandTest output = {OH_NN_FLOAT32, OH_NN_TENSOR, tensor_shape, outputValue, 9*sizeof(float)}; 35 OHNNOperandTest base = {OH_NN_FLOAT32, OH_NN_EXP_BASE, {1}, &baseValue, sizeof(float)}; 36 OHNNOperandTest scale = {OH_NN_FLOAT32, OH_NN_EXP_SCALE, {1}, &scaleValue, sizeof(float)}; 37 OHNNOperandTest shift = {OH_NN_FLOAT32, OH_NN_EXP_SHIFT, {1}, &scaleValue, sizeof(float)}; 38 OHNNGraphArgs graphArgs = {.operationType = OH_NN_OPS_EXP, 39 .operands = {input, output, base, scale, shift}, 40 .paramIndices = {2, 3, 4}, 41 .inputIndices = {0}, 42 .outputIndices = {1}}; 43 }; 44 45 struct ExpModel2 { 46 const std::vector<int32_t> tensor_shape = {3}; 47 float inputValue[3] = {0, 1, 2}; 48 float outputValue[3] = {0}; 49 50 OHNNOperandTest input = {OH_NN_FLOAT32, OH_NN_TENSOR, tensor_shape, inputValue, 3*sizeof(float)}; 51 OHNNOperandTest output = {OH_NN_FLOAT32, OH_NN_TENSOR, tensor_shape, outputValue, 3*sizeof(float)}; 52 OHNNGraphArgs graphArgs = {.operationType = OH_NN_OPS_EXP, 53 .operands = {input, output}, 54 .paramIndices = {}, 55 .inputIndices = {0}, 56 .outputIndices = {1}}; 57 }; 58 59 struct ExpModel3 { 60 const std::vector<int32_t> tensor_shape = {3, 3}; 61 float baseValue = 0; 62 float scaleValue = 1.5; 63 float shiftValue = 1; 64 float inputValue[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; 65 float outputValue[3][3] = {0}; 66 67 OHNNOperandTest input = {OH_NN_FLOAT32, OH_NN_TENSOR, tensor_shape, inputValue, 9*sizeof(float)}; 68 OHNNOperandTest output = {OH_NN_FLOAT32, OH_NN_TENSOR, tensor_shape, outputValue, 9*sizeof(float)}; 69 OHNNOperandTest base = {OH_NN_FLOAT32, OH_NN_EXP_BASE, {1}, &baseValue, sizeof(float)}; 70 OHNNOperandTest scale = {OH_NN_FLOAT32, OH_NN_EXP_SCALE, {1}, &scaleValue, sizeof(float)}; 71 OHNNOperandTest shift = {OH_NN_FLOAT32, OH_NN_EXP_SHIFT, {1}, &scaleValue, sizeof(float)}; 72 OHNNGraphArgs graphArgs = {.operationType = OH_NN_OPS_EXP, 73 .operands = {input, output, base, scale, shift}, 74 .paramIndices = {2, 3, 4}, 75 .inputIndices = {0}, 76 .outputIndices = {1}}; 77 }; 78 79 struct ExpModel4 { 80 const std::vector<int32_t> tensor_shape = {}; 81 float baseValue = 1; 82 float scaleValue = 1.5; 83 float shiftValue = 1; 84 float* inputValue = {}; 85 float* outputValue = {}; 86 87 OHNNOperandTest input = {OH_NN_FLOAT32, OH_NN_TENSOR, tensor_shape, inputValue, 0*sizeof(float)}; 88 OHNNOperandTest output = {OH_NN_FLOAT32, OH_NN_TENSOR, tensor_shape, outputValue, 0*sizeof(float)}; 89 OHNNOperandTest base = {OH_NN_FLOAT32, OH_NN_EXP_BASE, {1}, &baseValue, sizeof(float)}; 90 OHNNOperandTest scale = {OH_NN_FLOAT32, OH_NN_EXP_SCALE, {1}, &scaleValue, sizeof(float)}; 91 OHNNOperandTest shift = {OH_NN_FLOAT32, OH_NN_EXP_SHIFT, {1}, &scaleValue, sizeof(float)}; 92 OHNNGraphArgs graphArgs = {.operationType = OH_NN_OPS_EXP, 93 .operands = {input, output, base, scale, shift}, 94 .paramIndices = {2, 3, 4}, 95 .inputIndices = {0}, 96 .outputIndices = {1}}; 97 }; 98 99 /** 100 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Build_01 101 * @tc.desc: ExpModel1模型build测试 102 * @tc.type: FUNC 103 */ 104 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Build_01, Function | MediumTest | Level1) 105 { 106 OH_NNModel *model = OH_NNModel_Construct(); 107 EXPECT_NE(nullptr, model); 108 109 ExpModel1 expModel; 110 OHNNGraphArgs graphArgs = expModel.graphArgs; 111 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 112 113 OH_NNCompilation *compilation = OH_NNCompilation_Construct(model); 114 EXPECT_NE(nullptr, compilation); 115 116 OHNNCompileParam compileParam{ 117 .performanceMode = OH_NN_PERFORMANCE_HIGH, 118 .priority = OH_NN_PRIORITY_HIGH, 119 }; 120 EXPECT_EQ(OH_NN_SUCCESS, CompileGraphMock(compilation, compileParam)); 121 122 OH_NNExecutor *executor = OH_NNExecutor_Construct(compilation); 123 EXPECT_NE(nullptr, executor); 124 125 Free(model, compilation, executor); 126 } 127 128 /** 129 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Build_02 130 * @tc.desc: ExpModel2模型build测试 131 * @tc.type: FUNC 132 */ 133 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Build_02, Function | MediumTest | Level1) 134 { 135 OH_NNModel *model = OH_NNModel_Construct(); 136 EXPECT_NE(nullptr, model); 137 138 ExpModel2 expModel; 139 OHNNGraphArgs graphArgs = expModel.graphArgs; 140 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 141 142 OH_NNCompilation *compilation = OH_NNCompilation_Construct(model); 143 EXPECT_NE(nullptr, compilation); 144 145 OHNNCompileParam compileParam{ 146 .performanceMode = OH_NN_PERFORMANCE_HIGH, 147 .priority = OH_NN_PRIORITY_HIGH, 148 }; 149 EXPECT_EQ(OH_NN_SUCCESS, CompileGraphMock(compilation, compileParam)); 150 151 OH_NNExecutor *executor = OH_NNExecutor_Construct(compilation); 152 EXPECT_NE(nullptr, executor); 153 154 Free(model, compilation, executor); 155 } 156 157 /** 158 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Build_03 159 * @tc.desc: ExpModel3模型build测试 160 * @tc.type: FUNC 161 */ 162 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Build_03, Function | MediumTest | Level1) 163 { 164 OH_NNModel *model = OH_NNModel_Construct(); 165 EXPECT_NE(nullptr, model); 166 167 ExpModel3 expModel; 168 OHNNGraphArgs graphArgs = expModel.graphArgs; 169 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 170 171 OH_NNCompilation *compilation = OH_NNCompilation_Construct(model); 172 EXPECT_NE(nullptr, compilation); 173 174 OHNNCompileParam compileParam{ 175 .performanceMode = OH_NN_PERFORMANCE_HIGH, 176 .priority = OH_NN_PRIORITY_HIGH, 177 }; 178 EXPECT_EQ(OH_NN_SUCCESS, CompileGraphMock(compilation, compileParam)); 179 180 OH_NNExecutor *executor = OH_NNExecutor_Construct(compilation); 181 EXPECT_NE(nullptr, executor); 182 183 Free(model, compilation, executor); 184 } 185 186 /** 187 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Build_04 188 * @tc.desc: ExpModel4模型build测试 189 * @tc.type: FUNC 190 */ 191 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Build_04, Function | MediumTest | Level1) 192 { 193 OH_NNModel *model = OH_NNModel_Construct(); 194 EXPECT_NE(nullptr, model); 195 196 ExpModel4 expModel; 197 OHNNGraphArgs graphArgs = expModel.graphArgs; 198 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 199 200 OH_NNCompilation *compilation = OH_NNCompilation_Construct(model); 201 EXPECT_NE(nullptr, compilation); 202 203 OHNNCompileParam compileParam{ 204 .performanceMode = OH_NN_PERFORMANCE_HIGH, 205 .priority = OH_NN_PRIORITY_HIGH, 206 }; 207 EXPECT_EQ(OH_NN_SUCCESS, CompileGraphMock(compilation, compileParam)); 208 209 OH_NNExecutor *executor = OH_NNExecutor_Construct(compilation); 210 EXPECT_NE(nullptr, executor); 211 212 Free(model, compilation, executor); 213 } 214 215 /** 216 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Build_05 217 * @tc.desc: ExpModel1模型输入Tensor+1进行build测试 218 * @tc.type: FUNC 219 */ 220 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Build_05, Function | MediumTest | Level2) 221 { 222 OH_NNModel *model = OH_NNModel_Construct(); 223 EXPECT_NE(nullptr, model); 224 225 ExpModel1 expModel; 226 OHNNGraphArgs graphArgs = expModel.graphArgs; 227 graphArgs.operands = {expModel.input, expModel.input, expModel.output, 228 expModel.base, expModel.scale, expModel.shift}; 229 graphArgs.inputIndices = {0, 1}; 230 graphArgs.outputIndices = {2}; 231 graphArgs.paramIndices = {3, 4, 5}; 232 EXPECT_EQ(OH_NN_INVALID_PARAMETER, BuildSingleOpGraph(model, graphArgs)); 233 234 Free(model, nullptr, nullptr); 235 } 236 237 /** 238 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Build_06 239 * @tc.desc: ExpModel1模型输出Tensor+1进行build测试 240 * @tc.type: FUNC 241 */ 242 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Build_06, Function | MediumTest | Level2) 243 { 244 OH_NNModel *model = OH_NNModel_Construct(); 245 EXPECT_NE(nullptr, model); 246 247 ExpModel1 expModel; 248 OHNNGraphArgs graphArgs = expModel.graphArgs; 249 graphArgs.operands = {expModel.input, expModel.output, expModel.output, 250 expModel.base, expModel.scale, expModel.shift}; 251 graphArgs.inputIndices = {0}; 252 graphArgs.outputIndices = {1, 2}; 253 graphArgs.paramIndices = {3, 4, 5}; 254 EXPECT_EQ(OH_NN_INVALID_PARAMETER, BuildSingleOpGraph(model, graphArgs)); 255 256 Free(model, nullptr, nullptr); 257 } 258 259 /** 260 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Build_07 261 * @tc.desc: ExpModel1模型传入非法参数进行build测试 262 * @tc.type: FUNC 263 */ 264 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Build_07, Function | MediumTest | Level2) 265 { 266 OH_NNModel *model = OH_NNModel_Construct(); 267 EXPECT_NE(nullptr, model); 268 269 ExpModel1 expModel; 270 OHNNGraphArgs graphArgs = expModel.graphArgs; 271 272 int8_t activationValue = OH_NN_FUSED_NONE; 273 OHNNOperandTest activation = {OH_NN_INT8, OH_NN_ADD_ACTIVATIONTYPE, {}, &activationValue, sizeof(int8_t)}; 274 graphArgs.operands = {expModel.input, expModel.output, expModel.base, 275 expModel.scale, expModel.shift, activation}; 276 graphArgs.paramIndices = {2, 3, 4, 5}; 277 EXPECT_EQ(OH_NN_INVALID_PARAMETER, BuildSingleOpGraph(model, graphArgs)); 278 279 Free(model, nullptr, nullptr); 280 } 281 282 /** 283 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_Finish_01 284 * @tc.desc: 模型构图，未添加操作数 285 * @tc.type: FUNC 286 */ 287 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_Finish_01, Function | MediumTest | Level2) 288 { 289 OH_NNModel *model = OH_NNModel_Construct(); 290 EXPECT_NE(nullptr, model); 291 292 OHNNGraphArgs graphArgs; 293 EXPECT_EQ(OH_NN_INVALID_PARAMETER, SingleModelBuildEndStep(model, graphArgs)); 294 295 Free(model, nullptr, nullptr); 296 } 297 298 /** 299 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_Finish_02 300 * @tc.desc: 模型构图，未设置输入输出 301 * @tc.type: FUNC 302 */ 303 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_Finish_02, Function | MediumTest | Level2) 304 { 305 OH_NNModel *model = OH_NNModel_Construct(); 306 EXPECT_NE(nullptr, model); 307 308 ExpModel1 expModel; 309 OHNNGraphArgs graphArgs = expModel.graphArgs; 310 graphArgs.specifyIO = false; 311 EXPECT_EQ(OH_NN_OPERATION_FORBIDDEN, BuildSingleOpGraph(model, graphArgs)); 312 313 Free(model, nullptr, nullptr); 314 } 315 316 /** 317 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_Finish_03 318 * @tc.desc: 模型构图，设置输入输出，构图成功 319 * @tc.type: FUNC 320 */ 321 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_Finish_03, Function | MediumTest | Level1) 322 { 323 OH_NNModel *model = OH_NNModel_Construct(); 324 EXPECT_NE(nullptr, model); 325 326 ExpModel1 expModel; 327 OHNNGraphArgs graphArgs = expModel.graphArgs; 328 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 329 330 Free(model, nullptr, nullptr); 331 } 332 333 /** 334 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_SetOperandValue_01 335 * @tc.desc: 设置操作数值，操作数不存在 336 * @tc.type: FUNC 337 */ 338 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_SetOperandValue_01, Function | MediumTest | Level2) 339 { 340 OH_NNModel *model = OH_NNModel_Construct(); 341 EXPECT_NE(nullptr, model); 342 343 ExpModel1 expModel; 344 OHNNGraphArgs graphArgs = expModel.graphArgs; 345 346 NN_TensorDesc* tensorDesc = nullptr; 347 std::vector<NN_TensorDesc*> tensorDescVec; 348 349 for (size_t i = 0; i < graphArgs.operands.size(); i++) { 350 const OHNNOperandTest &operandTem = graphArgs.operands[i]; 351 tensorDesc = createTensorDesc(operandTem.shape.data(), 352 (uint32_t) operandTem.shape.size(), 353 operandTem.dataType, operandTem.format); 354 tensorDescVec.emplace_back(tensorDesc); 355 EXPECT_EQ(OH_NN_SUCCESS, OH_NNModel_AddTensorToModel(model, tensorDesc)); 356 EXPECT_EQ(OH_NN_SUCCESS, OH_NNModel_SetTensorType(model, i, operandTem.type)); 357 358 if (std::find(graphArgs.paramIndices.begin(), graphArgs.paramIndices.end(), i) != 359 graphArgs.paramIndices.end()) { 360 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_SetTensorData( 361 model, 1000+i, operandTem.data, operandTem.length)); 362 } 363 } 364 365 FreeTensorDescVec(tensorDescVec); 366 Free(model, nullptr, nullptr); 367 } 368 369 /** 370 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_SetOperandValue_02 371 * @tc.desc: 设置操作数值，buufer为nullptr 372 * @tc.type: FUNC 373 */ 374 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_SetOperandValue_02, Function | MediumTest | Level2) 375 { 376 OH_NNModel *model = OH_NNModel_Construct(); 377 EXPECT_NE(nullptr, model); 378 379 ExpModel1 expModel; 380 OHNNGraphArgs graphArgs = expModel.graphArgs; 381 382 NN_TensorDesc* tensorDesc = nullptr; 383 std::vector<NN_TensorDesc*> tensorDescVec; 384 385 for (size_t i = 0; i < graphArgs.operands.size(); i++) { 386 const OHNNOperandTest &operandTem = graphArgs.operands[i]; 387 tensorDesc = createTensorDesc(operandTem.shape.data(), 388 (uint32_t) operandTem.shape.size(), 389 operandTem.dataType, operandTem.format); 390 tensorDescVec.emplace_back(tensorDesc); 391 EXPECT_EQ(OH_NN_SUCCESS, OH_NNModel_AddTensorToModel(model, tensorDesc)); 392 EXPECT_EQ(OH_NN_SUCCESS, OH_NNModel_SetTensorType(model, i, operandTem.type)); 393 394 if (std::find(graphArgs.paramIndices.begin(), graphArgs.paramIndices.end(), i) != 395 graphArgs.paramIndices.end()) { 396 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_SetTensorData(model, i, nullptr, operandTem.length)); 397 } 398 } 399 400 FreeTensorDescVec(tensorDescVec); 401 Free(model, nullptr, nullptr); 402 } 403 404 /** 405 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_SetOperandValue_03 406 * @tc.desc: 设置操作数值，length为0 407 * @tc.type: FUNC 408 */ 409 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_SetOperandValue_03, Function | MediumTest | Level2) 410 { 411 OH_NNModel *model = OH_NNModel_Construct(); 412 EXPECT_NE(nullptr, model); 413 414 ExpModel1 expModel; 415 OHNNGraphArgs graphArgs = expModel.graphArgs; 416 417 NN_TensorDesc* tensorDesc = nullptr; 418 std::vector<NN_TensorDesc*> tensorDescVec; 419 420 for (size_t i = 0; i < graphArgs.operands.size(); i++) { 421 const OHNNOperandTest &operandTem = graphArgs.operands[i]; 422 tensorDesc = createTensorDesc(operandTem.shape.data(), 423 (uint32_t) operandTem.shape.size(), 424 operandTem.dataType, operandTem.format); 425 tensorDescVec.emplace_back(tensorDesc); 426 EXPECT_EQ(OH_NN_SUCCESS, OH_NNModel_AddTensorToModel(model, tensorDesc)); 427 EXPECT_EQ(OH_NN_SUCCESS, OH_NNModel_SetTensorType(model, i, operandTem.type)); 428 429 if (std::find(graphArgs.paramIndices.begin(), graphArgs.paramIndices.end(), i) != 430 graphArgs.paramIndices.end()) { 431 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_SetTensorData(model, 1000+i, operandTem.data, 0)); 432 } 433 } 434 435 FreeTensorDescVec(tensorDescVec); 436 Free(model, nullptr, nullptr); 437 } 438 439 /** 440 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_SpecifyInputsAndOutputs_01 441 * @tc.desc: 设置输入输出，inputIndices为nullptr 442 * @tc.type: FUNC 443 */ 444 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_SpecifyInputsAndOutputs_01, Function | MediumTest | Level2) 445 { 446 OH_NNModel *model = OH_NNModel_Construct(); 447 EXPECT_NE(nullptr, model); 448 449 ExpModel1 expModel; 450 OHNNGraphArgs graphArgs = expModel.graphArgs; 451 graphArgs.specifyIO = false; 452 graphArgs.build = false; 453 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 454 455 auto inputIndices = TransformUInt32Array(graphArgs.inputIndices); 456 auto outputIndices = TransformUInt32Array(graphArgs.outputIndices); 457 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_SpecifyInputsAndOutputs(model, nullptr, &outputIndices)); 458 459 Free(model, nullptr, nullptr); 460 } 461 462 /** 463 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_SpecifyInputsAndOutputs_02 464 * @tc.desc: 设置输入输出，inputindices中data为nullptr 465 * @tc.type: FUNC 466 */ 467 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_SpecifyInputsAndOutputs_02, Function | MediumTest | Level2) 468 { 469 OH_NNModel *model = OH_NNModel_Construct(); 470 EXPECT_NE(nullptr, model); 471 472 ExpModel1 expModel; 473 OHNNGraphArgs graphArgs = expModel.graphArgs; 474 graphArgs.specifyIO = false; 475 graphArgs.build = false; 476 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 477 478 auto inputIndices = TransformUInt32Array(graphArgs.inputIndices); 479 auto outputIndices = TransformUInt32Array(graphArgs.outputIndices); 480 inputIndices.data = nullptr; 481 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_SpecifyInputsAndOutputs(model, &inputIndices, &outputIndices)); 482 483 Free(model, nullptr, nullptr); 484 } 485 486 /** 487 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_SpecifyInputsAndOutputs_03 488 * @tc.desc: 设置输入输出，inputindices中data对应序号不存在 489 * @tc.type: FUNC 490 */ 491 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_SpecifyInputsAndOutputs_03, Function | MediumTest | Level2) 492 { 493 OH_NNModel *model = OH_NNModel_Construct(); 494 EXPECT_NE(nullptr, model); 495 496 ExpModel1 expModel; 497 OHNNGraphArgs graphArgs = expModel.graphArgs; 498 graphArgs.specifyIO = false; 499 graphArgs.build = false; 500 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 501 502 graphArgs.inputIndices = {100000}; 503 auto inputIndices = TransformUInt32Array(graphArgs.inputIndices); 504 auto outputIndices = TransformUInt32Array(graphArgs.outputIndices); 505 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_SpecifyInputsAndOutputs(model, &inputIndices, &outputIndices)); 506 507 Free(model, nullptr, nullptr); 508 } 509 510 /** 511 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_SpecifyInputsAndOutputs_04 512 * @tc.desc: 设置输入输出，inputindices中size为0 513 * @tc.type: FUNC 514 */ 515 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_SpecifyInputsAndOutputs_04, Function | MediumTest | Level2) 516 { 517 OH_NNModel *model = OH_NNModel_Construct(); 518 EXPECT_NE(nullptr, model); 519 520 ExpModel1 expModel; 521 OHNNGraphArgs graphArgs = expModel.graphArgs; 522 graphArgs.specifyIO = false; 523 graphArgs.build = false; 524 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 525 526 auto inputIndices = TransformUInt32Array(graphArgs.inputIndices); 527 auto outputIndices = TransformUInt32Array(graphArgs.outputIndices); 528 inputIndices.size = 0; 529 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_SpecifyInputsAndOutputs(model, &inputIndices, &outputIndices)); 530 531 Free(model, nullptr, nullptr); 532 } 533 534 /** 535 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_SpecifyInputsAndOutputs_05 536 * @tc.desc: 设置输入输出，outputindices为nullptr 537 * @tc.type: FUNC 538 */ 539 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_SpecifyInputsAndOutputs_05, Function | MediumTest | Level2) 540 { 541 OH_NNModel *model = OH_NNModel_Construct(); 542 EXPECT_NE(nullptr, model); 543 544 ExpModel1 expModel; 545 OHNNGraphArgs graphArgs = expModel.graphArgs; 546 graphArgs.specifyIO = false; 547 graphArgs.build = false; 548 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 549 550 auto inputIndices = TransformUInt32Array(graphArgs.inputIndices); 551 auto outputIndices = TransformUInt32Array(graphArgs.outputIndices); 552 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_SpecifyInputsAndOutputs(model, &inputIndices, nullptr)); 553 554 Free(model, nullptr, nullptr); 555 } 556 557 /** 558 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_SpecifyInputsAndOutputs_06 559 * @tc.desc: 设置输入输出，outputindices中data为nullptr 560 * @tc.type: FUNC 561 */ 562 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_SpecifyInputsAndOutputs_06, Function | MediumTest | Level2) 563 { 564 OH_NNModel *model = OH_NNModel_Construct(); 565 EXPECT_NE(nullptr, model); 566 567 ExpModel1 expModel; 568 OHNNGraphArgs graphArgs = expModel.graphArgs; 569 graphArgs.specifyIO = false; 570 graphArgs.build = false; 571 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 572 573 auto inputIndices = TransformUInt32Array(graphArgs.inputIndices); 574 auto outputIndices = TransformUInt32Array(graphArgs.outputIndices); 575 outputIndices.data = nullptr; 576 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_SpecifyInputsAndOutputs(model, &inputIndices, &outputIndices)); 577 578 Free(model, nullptr, nullptr); 579 } 580 581 /** 582 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_SpecifyInputsAndOutputs_07 583 * @tc.desc: 设置输入输出，outputindices中data对应序号不存在 584 * @tc.type: FUNC 585 */ 586 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_SpecifyInputsAndOutputs_07, Function | MediumTest | Level2) 587 { 588 OH_NNModel *model = OH_NNModel_Construct(); 589 EXPECT_NE(nullptr, model); 590 591 ExpModel1 expModel; 592 OHNNGraphArgs graphArgs = expModel.graphArgs; 593 graphArgs.specifyIO = false; 594 graphArgs.build = false; 595 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 596 597 graphArgs.outputIndices = {100000}; 598 auto inputIndices = TransformUInt32Array(graphArgs.inputIndices); 599 auto outputIndices = TransformUInt32Array(graphArgs.outputIndices); 600 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_SpecifyInputsAndOutputs(model, &inputIndices, &outputIndices)); 601 602 Free(model, nullptr, nullptr); 603 } 604 605 /** 606 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_SpecifyInputsAndOutputs_08 607 * @tc.desc: 设置输入输出，outputindices中size为0 608 * @tc.type: FUNC 609 */ 610 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_SpecifyInputsAndOutputs_08, Function | MediumTest | Level2) 611 { 612 OH_NNModel *model = OH_NNModel_Construct(); 613 EXPECT_NE(nullptr, model); 614 615 ExpModel1 expModel; 616 OHNNGraphArgs graphArgs = expModel.graphArgs; 617 graphArgs.specifyIO = false; 618 graphArgs.build = false; 619 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 620 621 auto inputIndices = TransformUInt32Array(graphArgs.inputIndices); 622 auto outputIndices = TransformUInt32Array(graphArgs.outputIndices); 623 outputIndices.size = 0; 624 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_SpecifyInputsAndOutputs(model, &inputIndices, &outputIndices)); 625 626 Free(model, nullptr, nullptr); 627 } 628 629 /** 630 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_01 631 * @tc.desc: 添加算子，paramindices为nullptr 632 * @tc.type: FUNC 633 */ 634 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_01, Function | MediumTest | Level2) 635 { 636 OH_NNModel *model = OH_NNModel_Construct(); 637 EXPECT_NE(nullptr, model); 638 639 ExpModel1 expModel; 640 OHNNGraphArgs graphArgs = expModel.graphArgs; 641 graphArgs.addOperation = false; 642 graphArgs.specifyIO = false; 643 graphArgs.build = false; 644 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 645 646 auto inputIndices = TransformUInt32Array(graphArgs.inputIndices); 647 auto outputIndices = TransformUInt32Array(graphArgs.outputIndices); 648 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_AddOperation(model, graphArgs.operationType, 649 nullptr, &inputIndices, &outputIndices)); 650 651 Free(model, nullptr, nullptr); 652 } 653 654 /** 655 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_02 656 * @tc.desc: 添加算子，paramindices中data为nullptr 657 * @tc.type: FUNC 658 */ 659 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_02, Function | MediumTest | Level2) 660 { 661 OH_NNModel *model = OH_NNModel_Construct(); 662 EXPECT_NE(nullptr, model); 663 664 ExpModel1 expModel; 665 OHNNGraphArgs graphArgs = expModel.graphArgs; 666 graphArgs.addOperation = false; 667 graphArgs.specifyIO = false; 668 graphArgs.build = false; 669 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 670 671 auto paramIndices = TransformUInt32Array(graphArgs.paramIndices); 672 auto inputIndices = TransformUInt32Array(graphArgs.inputIndices); 673 auto outputIndices = TransformUInt32Array(graphArgs.outputIndices); 674 paramIndices.data = nullptr; 675 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_AddOperation(model, graphArgs.operationType, 676 ¶mIndices, &inputIndices, &outputIndices)); 677 678 Free(model, nullptr, nullptr); 679 } 680 681 /** 682 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_03 683 * @tc.desc: 添加算子，paramindices中data对应序号不存在 684 * @tc.type: FUNC 685 */ 686 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_03, Function | MediumTest | Level2) 687 { 688 OH_NNModel *model = OH_NNModel_Construct(); 689 EXPECT_NE(nullptr, model); 690 691 ExpModel1 expModel; 692 OHNNGraphArgs graphArgs = expModel.graphArgs; 693 graphArgs.addOperation = false; 694 graphArgs.specifyIO = false; 695 graphArgs.build = false; 696 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 697 698 graphArgs.paramIndices = {100000}; 699 auto paramIndices = TransformUInt32Array(graphArgs.paramIndices); 700 auto inputIndices = TransformUInt32Array(graphArgs.inputIndices); 701 auto outputIndices = TransformUInt32Array(graphArgs.outputIndices); 702 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_AddOperation(model, graphArgs.operationType, 703 ¶mIndices, &inputIndices, &outputIndices)); 704 705 Free(model, nullptr, nullptr); 706 } 707 708 /** 709 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_04 710 * @tc.desc: 添加算子，paramindices中size为0 711 * @tc.type: FUNC 712 */ 713 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_04, Function | MediumTest | Level2) 714 { 715 OH_NNModel *model = OH_NNModel_Construct(); 716 EXPECT_NE(nullptr, model); 717 718 ExpModel1 expModel; 719 OHNNGraphArgs graphArgs = expModel.graphArgs; 720 graphArgs.addOperation = false; 721 graphArgs.specifyIO = false; 722 graphArgs.build = false; 723 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 724 725 auto paramIndices = TransformUInt32Array(graphArgs.paramIndices); 726 auto inputIndices = TransformUInt32Array(graphArgs.inputIndices); 727 auto outputIndices = TransformUInt32Array(graphArgs.outputIndices); 728 paramIndices.size = 0; 729 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_AddOperation(model, graphArgs.operationType, 730 ¶mIndices, &inputIndices, &outputIndices)); 731 732 Free(model, nullptr, nullptr); 733 } 734 735 /** 736 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_05 737 * @tc.desc: 添加算子，inputindices为nullptr 738 * @tc.type: FUNC 739 */ 740 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_05, Function | MediumTest | Level2) 741 { 742 OH_NNModel *model = OH_NNModel_Construct(); 743 EXPECT_NE(nullptr, model); 744 745 ExpModel1 expModel; 746 OHNNGraphArgs graphArgs = expModel.graphArgs; 747 graphArgs.addOperation = false; 748 graphArgs.specifyIO = false; 749 graphArgs.build = false; 750 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 751 752 auto paramIndices = TransformUInt32Array(graphArgs.paramIndices); 753 auto outputIndices = TransformUInt32Array(graphArgs.outputIndices); 754 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_AddOperation(model, graphArgs.operationType, 755 ¶mIndices, nullptr, &outputIndices)); 756 757 Free(model, nullptr, nullptr); 758 } 759 760 /** 761 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_06 762 * @tc.desc: 添加算子，inputindices中data为nullptr 763 * @tc.type: FUNC 764 */ 765 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_06, Function | MediumTest | Level2) 766 { 767 OH_NNModel *model = OH_NNModel_Construct(); 768 EXPECT_NE(nullptr, model); 769 770 ExpModel1 expModel; 771 OHNNGraphArgs graphArgs = expModel.graphArgs; 772 graphArgs.addOperation = false; 773 graphArgs.specifyIO = false; 774 graphArgs.build = false; 775 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 776 777 auto paramIndices = TransformUInt32Array(graphArgs.paramIndices); 778 auto inputIndices = TransformUInt32Array(graphArgs.inputIndices); 779 auto outputIndices = TransformUInt32Array(graphArgs.outputIndices); 780 inputIndices.data = nullptr; 781 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_AddOperation(model, graphArgs.operationType, 782 ¶mIndices, &inputIndices, &outputIndices)); 783 784 Free(model, nullptr, nullptr); 785 } 786 787 /** 788 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_07 789 * @tc.desc: 添加算子，inputindices中data对应序号不存在 790 * @tc.type: FUNC 791 */ 792 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_07, Function | MediumTest | Level2) 793 { 794 OH_NNModel *model = OH_NNModel_Construct(); 795 EXPECT_NE(nullptr, model); 796 797 ExpModel1 expModel; 798 OHNNGraphArgs graphArgs = expModel.graphArgs; 799 graphArgs.addOperation = false; 800 graphArgs.specifyIO = false; 801 graphArgs.build = false; 802 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 803 804 graphArgs.inputIndices = {100000}; 805 auto paramIndices = TransformUInt32Array(graphArgs.paramIndices); 806 auto inputIndices = TransformUInt32Array(graphArgs.inputIndices); 807 auto outputIndices = TransformUInt32Array(graphArgs.outputIndices); 808 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_AddOperation(model, graphArgs.operationType, 809 ¶mIndices, &inputIndices, &outputIndices)); 810 811 Free(model, nullptr, nullptr); 812 } 813 814 /** 815 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_08 816 * @tc.desc: 添加算子，inputindices中size为0 817 * @tc.type: FUNC 818 */ 819 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_08, Function | MediumTest | Level2) 820 { 821 OH_NNModel *model = OH_NNModel_Construct(); 822 EXPECT_NE(nullptr, model); 823 824 ExpModel1 expModel; 825 OHNNGraphArgs graphArgs = expModel.graphArgs; 826 graphArgs.addOperation = false; 827 graphArgs.specifyIO = false; 828 graphArgs.build = false; 829 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 830 831 auto paramIndices = TransformUInt32Array(graphArgs.paramIndices); 832 auto inputIndices = TransformUInt32Array(graphArgs.inputIndices); 833 auto outputIndices = TransformUInt32Array(graphArgs.outputIndices); 834 inputIndices.size = 0; 835 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_AddOperation(model, graphArgs.operationType, 836 ¶mIndices, &inputIndices, &outputIndices)); 837 838 Free(model, nullptr, nullptr); 839 } 840 841 /** 842 * @tc.number : SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_09 843 * @tc.desc: 添加算子，outputindices为nullptr 844 * @tc.type: FUNC 845 */ 846 HWTEST_F(ExpTest, SUB_AI_NNRt_Func_North_Exp_Model_AddOperation_09, Function | MediumTest | Level2) 847 { 848 OH_NNModel *model = OH_NNModel_Construct(); 849 EXPECT_NE(nullptr, model); 850 851 ExpModel1 expModel; 852 OHNNGraphArgs graphArgs = expModel.graphArgs; 853 graphArgs.addOperation = false; 854 graphArgs.specifyIO = false; 855 graphArgs.build = false; 856 EXPECT_EQ(OH_NN_SUCCESS, BuildSingleOpGraph(model, graphArgs)); 857 858 auto paramIndices = TransformUInt32Array(graphArgs.paramIndices); 859 auto inputIndices = TransformUInt32Array(graphArgs.inputIndices); 860 EXPECT_EQ(OH_NN_INVALID_PARAMETER, OH_NNModel_AddOperation(nullptr, graphArgs.operationType, 861 ¶mIndices, &inputIndices, nullptr)); 862 863 Free(model, nullptr, nullptr); 864 }