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