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