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