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