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