1 /*
2 * Copyright (c) 2022 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 "ops/conv2d_builder.h"
17
18 #include "ops_test.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22 using namespace OHOS::NeuralNetworkRuntime::Ops;
23
24 namespace OHOS {
25 namespace NeuralNetworkRuntime {
26 namespace UnitTest {
27 class Conv2DBuilderTest : public OpsTest {
28 public:
29 void SetUp() override;
30 void TearDown() override;
31
32 void SetConv2dInput();
33 void SetPad(OH_NN_DataType dataType,
34 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
35 void SetPadParam();
36
37 public:
38 Conv2DBuilder m_builder;
39 std::vector<uint32_t> m_inputs{0, 1, 2};
40 std::vector<uint32_t> m_outputs{3};
41 std::vector<uint32_t> m_params{4, 5, 6, 7, 8};
42 std::vector<int32_t> m_output_dim{1, 3, 3, 1};
43 std::vector<int32_t> m_stride_dim{2};
44 std::vector<int32_t> m_dilation_dim{2};
45 std::vector<int32_t> m_pad_dim{4};
46 std::vector<int32_t> m_param_dim{};
47 };
48
SetUp()49 void Conv2DBuilderTest::SetUp() {}
50
TearDown()51 void Conv2DBuilderTest::TearDown() {}
52
SetPad(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)53 void Conv2DBuilderTest::SetPad(OH_NN_DataType dataType,
54 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
55 {
56 int32_t padNum = 4;
57 std::shared_ptr<NNTensor> tensor = TransToNNTensor(dataType, dim, quantParam, type);
58 int64_t* padValue = new (std::nothrow) int64_t[4]{1, 1, 1, 1};
59 EXPECT_NE(nullptr, padValue);
60 tensor->SetBuffer(padValue, padNum * sizeof(int64_t));
61 m_allTensors.emplace_back(tensor);
62 }
63
SetPadParam()64 void Conv2DBuilderTest::SetPadParam()
65 {
66 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_STRIDES);
67 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_DILATION);
68 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_PAD);
69 SetGroup(OH_NN_INT64, m_param_dim, nullptr, OH_NN_CONV2D_GROUP);
70 SetActivation(OH_NN_INT8, m_param_dim, nullptr, OH_NN_CONV2D_ACTIVATION_TYPE);
71 }
72
SetConv2dInput()73 void Conv2DBuilderTest::SetConv2dInput()
74 {
75 int32_t weightNum = 4;
76 std::vector<int32_t> m_input_dim{1, 4, 4, 1};
77 std::vector<int32_t> weightDim = {1, 2, 2, 1};
78 std::vector<int32_t> biasDim = {1};
79 std::shared_ptr<NNTensor> inputsTensor;
80 inputsTensor = TransToNNTensor(OH_NN_FLOAT32, m_input_dim, nullptr, OH_NN_TENSOR);
81 m_allTensors.emplace_back(inputsTensor);
82
83 inputsTensor = TransToNNTensor(OH_NN_FLOAT32, weightDim, nullptr, OH_NN_TENSOR);
84 float* weightValue = new (std::nothrow) float[4]{1, 1, 1, 1};
85 EXPECT_NE(nullptr, weightValue);
86
87 inputsTensor->SetBuffer(weightValue, weightNum * sizeof(weightValue));
88 m_allTensors.emplace_back(inputsTensor);
89 inputsTensor = TransToNNTensor(OH_NN_FLOAT32, biasDim, nullptr, OH_NN_TENSOR);
90 float* biasValue = new (std::nothrow) float[1]{0};
91 EXPECT_NE(nullptr, biasValue);
92
93 inputsTensor->SetBuffer(biasValue, sizeof(float));
94 m_allTensors.emplace_back(inputsTensor);
95 }
96
97 /**
98 * @tc.name: conv2d_build_pad_001
99 * @tc.desc: Verify the success of the build function
100 * @tc.type: FUNC
101 */
102 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_001, TestSize.Level1)
103 {
104 m_paramsIndex = m_params;
105 m_inputsIndex = m_inputs;
106
107 SetConv2dInput();
108 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
109 SetPadParam();
110 EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
111 }
112
113 /**
114 * @tc.name: conv2d_build_pad_002
115 * @tc.desc: Verify the forbidden of the build function
116 * @tc.type: FUNC
117 */
118 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_002, TestSize.Level1)
119 {
120 m_paramsIndex = m_params;
121 m_inputsIndex = m_inputs;
122
123 SetConv2dInput();
124 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
125 SetPadParam();
126
127 EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
128 EXPECT_EQ(OH_NN_OPERATION_FORBIDDEN, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
129 }
130
131 /**
132 * @tc.name: conv2d_build_pad_003
133 * @tc.desc: Verify the missing input of the build function
134 * @tc.type: FUNC
135 */
136 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_003, TestSize.Level1)
137 {
138 m_inputs = {0};
139 m_outputs = {1};
140 m_params = {2, 3, 4, 5, 6};
141 m_paramsIndex = m_params;
142 m_inputsIndex = m_inputs;
143
144 SetConv2dInput();
145 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
146 SetPadParam();
147 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
148 }
149
150 /**
151 * @tc.name: conv2d_build_pad_004
152 * @tc.desc: Verify the missing output of the build function
153 * @tc.type: FUNC
154 */
155 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_004, TestSize.Level1)
156 {
157 m_inputs = {0, 1, 2};
158 m_outputs = {};
159 m_params = {3, 4, 5, 6, 7};
160 m_paramsIndex = m_params;
161 m_inputsIndex = m_inputs;
162
163 SetConv2dInput();
164 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
165 SetPadParam();
166 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
167 }
168 /**
169 * @tc.name: conv2d_build_pad_005
170 * @tc.desc: Verify the inputIndex out of bounds of the build function
171 * @tc.type: FUNC
172 */
173 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_005, TestSize.Level1)
174 {
175 m_inputs = {0, 1, 9};
176 m_outputs = {3};
177 m_params = {4, 5, 6, 7, 8};
178 m_paramsIndex = m_params;
179 m_inputsIndex = m_inputs;
180
181 SetConv2dInput();
182 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
183 SetPadParam();
184 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
185 }
186
187 /**
188 * @tc.name: conv2d_build_pad_006
189 * @tc.desc: Verify the outputIndex out of bounds of the build function
190 * @tc.type: FUNC
191 */
192 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_006, TestSize.Level1)
193 {
194 m_inputs = {0, 1, 2};
195 m_outputs = {9};
196 m_params = {4, 5, 6, 7, 8};
197 m_paramsIndex = m_params;
198 m_inputsIndex = m_inputs;
199
200 SetConv2dInput();
201 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
202 SetPadParam();
203 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
204 }
205
206 /**
207 * @tc.name: conv2d_build_pad_007
208 * @tc.desc: Verify the invalid stride of the build function
209 * @tc.type: FUNC
210 */
211 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_007, TestSize.Level1)
212 {
213 m_paramsIndex = m_params;
214 m_inputsIndex = m_inputs;
215
216 SetConv2dInput();
217 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
218 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT32, m_stride_dim, nullptr, OH_NN_CONV2D_STRIDES);
219 int32_t* strideValue = new (std::nothrow) int32_t[2]{1, 1};
220 EXPECT_NE(nullptr, strideValue);
221
222 tensor->SetBuffer(strideValue, 2 * sizeof(int32_t));
223 m_allTensors.emplace_back(tensor);
224 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_DILATION);
225 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_PAD);
226 SetGroup(OH_NN_INT64, m_param_dim, nullptr, OH_NN_CONV2D_GROUP);
227 SetActivation(OH_NN_INT8, m_param_dim, nullptr, OH_NN_CONV2D_ACTIVATION_TYPE);
228 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
229 }
230
231 /**
232 * @tc.name: conv2d_build_pad_008
233 * @tc.desc: Verify the invalid dilation of the build function
234 * @tc.type: FUNC
235 */
236 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_008, TestSize.Level1)
237 {
238 m_paramsIndex = m_params;
239 m_inputsIndex = m_inputs;
240
241 SetConv2dInput();
242 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
243 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_STRIDES);
244
245 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT32, m_dilation_dim, nullptr, OH_NN_CONV2D_DILATION);
246 int32_t* dilationValue = new (std::nothrow) int32_t[2]{1, 1};
247 EXPECT_NE(nullptr, dilationValue);
248
249 tensor->SetBuffer(dilationValue, 2 * sizeof(int32_t));
250 m_allTensors.emplace_back(tensor);
251 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_PAD);
252 SetGroup(OH_NN_INT64, m_param_dim, nullptr, OH_NN_CONV2D_GROUP);
253 SetActivation(OH_NN_INT8, m_param_dim, nullptr, OH_NN_CONV2D_ACTIVATION_TYPE);
254 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
255 }
256
257 /**
258 * @tc.name: conv2d_build_pad_009
259 * @tc.desc: Verify the invalid pad of the build function
260 * @tc.type: FUNC
261 */
262 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_009, TestSize.Level1)
263 {
264 m_paramsIndex = m_params;
265 m_inputsIndex = m_inputs;
266 SetConv2dInput();
267
268 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
269 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_STRIDES);
270 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_DILATION);
271 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT32, m_pad_dim, nullptr, OH_NN_CONV2D_PAD);
272
273 int32_t* padValue = new (std::nothrow) int32_t[4]{1, 1, 1, 1};
274 EXPECT_NE(nullptr, padValue);
275 tensor->SetBuffer(padValue, 4 * sizeof(int32_t));
276 m_allTensors.emplace_back(tensor);
277
278 SetGroup(OH_NN_INT64, m_param_dim, nullptr, OH_NN_CONV2D_GROUP);
279 SetActivation(OH_NN_INT8, m_param_dim, nullptr, OH_NN_CONV2D_ACTIVATION_TYPE);
280 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
281 }
282
283 /**
284 * @tc.name: conv2d_build_pad_010
285 * @tc.desc: Verify the invalid group of the build function
286 * @tc.type: FUNC
287 */
288 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_010, TestSize.Level1)
289 {
290 m_paramsIndex = m_params;
291 m_inputsIndex = m_inputs;
292
293 SetConv2dInput();
294 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
295 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_STRIDES);
296 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_DILATION);
297 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_PAD);
298 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT32, m_param_dim, nullptr, OH_NN_CONV2D_GROUP);
299
300 int32_t* groupValue = new (std::nothrow) int32_t(0);
301 EXPECT_NE(nullptr, groupValue);
302 tensor->SetBuffer(groupValue, sizeof(int32_t));
303 m_allTensors.emplace_back(tensor);
304 SetActivation(OH_NN_INT8, m_param_dim, nullptr, OH_NN_CONV2D_ACTIVATION_TYPE);
305 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
306 }
307
308
309 /**
310 * @tc.name: conv2d_build_pad_011
311 * @tc.desc: Verify the invalid activation of the build function
312 * @tc.type: FUNC
313 */
314 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_011, TestSize.Level1)
315 {
316 m_paramsIndex = m_params;
317 m_inputsIndex = m_inputs;
318 SetConv2dInput();
319 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
320 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_STRIDES);
321 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_DILATION);
322
323 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_PAD);
324 SetGroup(OH_NN_INT64, m_param_dim, nullptr, OH_NN_CONV2D_GROUP);
325 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT32, m_param_dim, nullptr, OH_NN_CONV2D_ACTIVATION_TYPE);
326 int32_t* activationValue = new (std::nothrow) int32_t(0);
327 EXPECT_NE(nullptr, activationValue);
328
329 tensor->SetBuffer(activationValue, sizeof(int32_t));
330 m_allTensors.emplace_back(tensor);
331 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
332 }
333
334 /**
335 * @tc.name: conv2d_build_pad_012
336 * @tc.desc: Verify the group scalar length of the build function
337 * @tc.type: FUNC
338 */
339 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_012, TestSize.Level1)
340 {
341 std::vector<int32_t> groupDim = {2};
342 m_paramsIndex = m_params;
343 m_inputsIndex = m_inputs;
344
345 SetConv2dInput();
346 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
347 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_STRIDES);
348 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_DILATION);
349 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_PAD);
350
351 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT64, groupDim, nullptr, OH_NN_CONV2D_GROUP);
352 int64_t* groupValue = new (std::nothrow) int64_t[2]{0, 0};
353 EXPECT_NE(nullptr, groupValue);
354
355 tensor->SetBuffer(groupValue, 2 * sizeof(int64_t));
356 m_allTensors.emplace_back(tensor);
357 SetActivation(OH_NN_INT8, m_param_dim, nullptr, OH_NN_CONV2D_ACTIVATION_TYPE);
358 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
359 }
360
361 /**
362 * @tc.name: conv2d_build_pad_013
363 * @tc.desc: Verify the scalar activation of the build function
364 * @tc.type: FUNC
365 */
366 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_013, TestSize.Level1)
367 {
368 std::vector<int32_t> activationDim = {2};
369 m_paramsIndex = m_params;
370 m_inputsIndex = m_inputs;
371
372 SetConv2dInput();
373 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
374 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_STRIDES);
375 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_DILATION);
376 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_PAD);
377 SetGroup(OH_NN_INT64, m_param_dim, nullptr, OH_NN_CONV2D_GROUP);
378
379 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT8, activationDim, nullptr,
380 OH_NN_CONV2D_ACTIVATION_TYPE);
381 int8_t* activationValue = new (std::nothrow) int8_t[2]{0, 0};
382 EXPECT_NE(nullptr, activationValue);
383 tensor->SetBuffer(activationValue, 2 * sizeof(int8_t));
384 m_allTensors.emplace_back(tensor);
385 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
386 }
387
388 /**
389 * @tc.name: conv2d_build_pad_014
390 * @tc.desc: Verify the conv2d without set stride of the build function
391 * @tc.type: FUNC
392 */
393 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_014, TestSize.Level1)
394 {
395 m_paramsIndex = m_params;
396 m_inputsIndex = m_inputs;
397 SetConv2dInput();
398
399 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
400 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT64, m_stride_dim, nullptr,
401 OH_NN_CONV2D_STRIDES);
402 m_allTensors.emplace_back(tensor);
403
404 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_DILATION);
405 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_PAD);
406 SetGroup(OH_NN_INT64, m_param_dim, nullptr, OH_NN_CONV2D_GROUP);
407 SetActivation(OH_NN_INT8, m_param_dim, nullptr, OH_NN_CONV2D_ACTIVATION_TYPE);
408 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
409 }
410
411 /**
412 * @tc.name: conv2d_build_pad_015
413 * @tc.desc: Verify the conv2d without set dilation of the build function
414 * @tc.type: FUNC
415 */
416 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_015, TestSize.Level1)
417 {
418 m_paramsIndex = m_params;
419 m_inputsIndex = m_inputs;
420
421 SetConv2dInput();
422 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
423 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_STRIDES);
424
425 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT64, m_dilation_dim, nullptr,
426 OH_NN_CONV2D_DILATION);
427 m_allTensors.emplace_back(tensor);
428
429 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_PAD);
430 SetGroup(OH_NN_INT64, m_param_dim, nullptr, OH_NN_CONV2D_GROUP);
431 SetActivation(OH_NN_INT8, m_param_dim, nullptr, OH_NN_CONV2D_ACTIVATION_TYPE);
432 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
433 }
434
435 /**
436 * @tc.name: conv2d_build_pad_016
437 * @tc.desc: Verify the conv2d without set pad of the build function
438 * @tc.type: FUNC
439 */
440 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_016, TestSize.Level1)
441 {
442 m_paramsIndex = m_params;
443 m_inputsIndex = m_inputs;
444
445 SetConv2dInput();
446 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
447 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_STRIDES);
448 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_DILATION);
449 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT64, m_pad_dim, nullptr,
450 OH_NN_CONV2D_PAD);
451 m_allTensors.emplace_back(tensor);
452
453 SetGroup(OH_NN_INT64, m_param_dim, nullptr, OH_NN_CONV2D_GROUP);
454 SetActivation(OH_NN_INT8, m_param_dim, nullptr, OH_NN_CONV2D_ACTIVATION_TYPE);
455 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
456 }
457
458 /**
459 * @tc.name: conv2d_build_pad_017
460 * @tc.desc: Verify the conv2d without set group of the build function
461 * @tc.type: FUNC
462 */
463 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_017, TestSize.Level1)
464 {
465 m_paramsIndex = m_params;
466 m_inputsIndex = m_inputs;
467
468 SetConv2dInput();
469 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
470 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_STRIDES);
471 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_DILATION);
472 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_PAD);
473 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT64, m_param_dim, nullptr,
474 OH_NN_CONV2D_GROUP);
475 m_allTensors.emplace_back(tensor);
476
477 SetActivation(OH_NN_INT8, m_param_dim, nullptr, OH_NN_CONV2D_ACTIVATION_TYPE);
478 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
479 }
480
481 /**
482 * @tc.name: conv2d_build_pad_018
483 * @tc.desc: Verify the conv2d without set activation of the build function
484 * @tc.type: FUNC
485 */
486 HWTEST_F(Conv2DBuilderTest, conv2d_build_pad_018, TestSize.Level1)
487 {
488 m_paramsIndex = m_params;
489 m_inputsIndex = m_inputs;
490
491 SetConv2dInput();
492 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
493 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_STRIDES);
494 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_DILATION);
495 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_PAD);
496 SetGroup(OH_NN_INT64, m_param_dim, nullptr, OH_NN_CONV2D_GROUP);
497 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT8, m_param_dim, nullptr,
498 OH_NN_CONV2D_ACTIVATION_TYPE);
499 m_allTensors.emplace_back(tensor);
500
501 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
502 }
503
504 /**
505 * @tc.name: conv2d_getprimitive_pad_001
506 * @tc.desc: Verify the nullptr return of the GetPrimitive function
507 * @tc.type: FUNC
508 */
509 HWTEST_F(Conv2DBuilderTest, conv2d_getprimitive_pad_001, TestSize.Level1)
510 {
511 m_paramsIndex = m_params;
512 m_inputsIndex = m_inputs;
513
514 SetConv2dInput();
515 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
516 SetPadParam();
517 EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
518
519 LiteGraphTensorPtr primitive = m_builder.GetPrimitive();
520 LiteGraphTensorPtr expectPrimitive(nullptr, DestroyLiteGraphPrimitive);
521 EXPECT_NE(expectPrimitive, primitive);
522
523 std::vector<int64_t> returnStrides = mindspore::lite::MindIR_Conv2DFusion_GetStride(primitive.get());
524 std::vector<int64_t> strideValueTest{1, 1};
525 EXPECT_EQ(strideValueTest, returnStrides);
526
527 std::vector<int64_t> returnDliation = mindspore::lite::MindIR_Conv2DFusion_GetDilation(primitive.get());
528 std::vector<int64_t> dilationValueTest{1, 1};
529 EXPECT_EQ(dilationValueTest, returnDliation);
530
531 std::vector<int64_t> returnPaddings = mindspore::lite::MindIR_Conv2DFusion_GetPadList(primitive.get());
532 std::vector<int64_t> padValueTest{1, 1, 1, 1};
533 EXPECT_EQ(padValueTest, returnPaddings);
534
535 int returnGroup = mindspore::lite::MindIR_Conv2DFusion_GetGroup(primitive.get());
536 EXPECT_EQ(0, returnGroup);
537 int returnActivation = mindspore::lite::MindIR_Conv2DFusion_GetActivationType(primitive.get());
538 EXPECT_EQ(0, returnActivation);
539 }
540
541 /**
542 * @tc.name: conv2d_getprimitive_pad_002
543 * @tc.desc: Verify the behavior of the GetPrimitive function
544 * @tc.type: FUNC
545 */
546 HWTEST_F(Conv2DBuilderTest, conv2d_getprimitive_pad_002, TestSize.Level1)
547 {
548 m_paramsIndex = m_params;
549 m_inputsIndex = m_inputs;
550
551 SetConv2dInput();
552 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
553 SetPadParam();
554
555 LiteGraphTensorPtr primitive = m_builder.GetPrimitive();
556 LiteGraphTensorPtr expectPrimitive(nullptr, DestroyLiteGraphPrimitive);
557 EXPECT_EQ(expectPrimitive, primitive);
558 }
559 } // namespace UnitTest
560 } // namespace NeuralNetworkRuntime
561 } // namespace OHOS
562