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_transpose_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 Conv2DTransposeBuilderTest : public OpsTest {
28 public:
29 void SetUp() override;
30 void TearDown() override;
31
32 void SetConv2dTransposeInput();
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 SetOutPaddings(OH_NN_DataType dataType,
36 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
37 void SetPadParam();
38
39 public:
40 Conv2DTransposeBuilder m_builder;
41 std::vector<uint32_t> m_inputs{0, 1, 2};
42 std::vector<uint32_t> m_outputs{3};
43 std::vector<uint32_t> m_params{4, 5, 6, 7, 8, 9};
44 std::vector<int32_t> m_output_dim{1, 3, 3, 1};
45 std::vector<int32_t> m_stride_dim{2};
46 std::vector<int32_t> m_dilation_dim{2};
47 std::vector<int32_t> m_outpaddings_dim{2};
48 std::vector<int32_t> m_pad_dim{4};
49 std::vector<int32_t> m_param_dim{};
50 };
51
SetUp()52 void Conv2DTransposeBuilderTest::SetUp() {}
53
TearDown()54 void Conv2DTransposeBuilderTest::TearDown() {}
55
SetPad(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)56 void Conv2DTransposeBuilderTest::SetPad(OH_NN_DataType dataType,
57 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
58 {
59 int32_t padNum = 4;
60 std::shared_ptr<NNTensor> tensor = TransToNNTensor(dataType, dim, quantParam, type);
61 int64_t* padValue = new (std::nothrow) int64_t[4]{1, 1, 1, 1};
62 EXPECT_NE(nullptr, padValue);
63
64 tensor->SetBuffer(padValue, padNum * sizeof(int64_t));
65 m_allTensors.emplace_back(tensor);
66 }
67
SetOutPaddings(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)68 void Conv2DTransposeBuilderTest::SetOutPaddings(OH_NN_DataType dataType,
69 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
70 {
71 int32_t outPaddingsNum = 2;
72 std::shared_ptr<NNTensor> tensor = TransToNNTensor(dataType, dim, quantParam, type);
73 int64_t* outPaddingsValue = new (std::nothrow) int64_t[2]{0, 0};
74 EXPECT_NE(nullptr, outPaddingsValue);
75
76 tensor->SetBuffer(outPaddingsValue, outPaddingsNum * sizeof(int64_t));
77 m_allTensors.emplace_back(tensor);
78 }
79
SetPadParam()80 void Conv2DTransposeBuilderTest::SetPadParam()
81 {
82 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_STRIDES);
83 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_DILATION);
84 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_PAD);
85 SetOutPaddings(OH_NN_INT64, m_outpaddings_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_OUTPUT_PADDINGS);
86 SetGroup(OH_NN_INT64, m_param_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_GROUP);
87 SetActivation(OH_NN_INT8, m_param_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_ACTIVATION_TYPE);
88 }
89
SetConv2dTransposeInput()90 void Conv2DTransposeBuilderTest::SetConv2dTransposeInput()
91 {
92 int32_t weightNum = 4;
93 std::vector<int32_t> m_input_dim{1, 4, 4, 1};
94 std::vector<int32_t> weightDim = {1, 2, 2, 1};
95 std::vector<int32_t> biasDim = {1};
96 std::shared_ptr<NNTensor> tensor;
97 tensor = TransToNNTensor(OH_NN_FLOAT32, m_input_dim, nullptr, OH_NN_TENSOR);
98 m_allTensors.emplace_back(tensor);
99
100 tensor = TransToNNTensor(OH_NN_FLOAT32, weightDim, nullptr, OH_NN_TENSOR);
101 float* weightValue = new (std::nothrow) float[4]{1, 1, 1, 1};
102 EXPECT_NE(nullptr, weightValue);
103
104 tensor->SetBuffer(weightValue, weightNum * sizeof(weightValue));
105 m_allTensors.emplace_back(tensor);
106 tensor = TransToNNTensor(OH_NN_FLOAT32, biasDim, nullptr, OH_NN_TENSOR);
107 float* biasValue = new (std::nothrow) float[1]{0};
108 EXPECT_NE(nullptr, biasValue);
109
110 tensor->SetBuffer(biasValue, sizeof(float));
111 m_allTensors.emplace_back(tensor);
112 }
113
114 /**
115 * @tc.name: conv2dtranpose_build_pad_001
116 * @tc.desc: Verify the success of the build function
117 * @tc.type: FUNC
118 */
119 HWTEST_F(Conv2DTransposeBuilderTest, conv2dtranpose_build_pad_001, TestSize.Level1)
120 {
121 SetConv2dTransposeInput();
122 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
123 SetPadParam();
124
125 m_paramsIndex = m_params;
126 m_inputsIndex = m_inputs;
127 EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
128 }
129
130 /**
131 * @tc.name: conv2dtranpose_build_pad_002
132 * @tc.desc: Verify the forbidden of the build function
133 * @tc.type: FUNC
134 */
135 HWTEST_F(Conv2DTransposeBuilderTest, conv2dtranpose_build_pad_002, TestSize.Level1)
136 {
137 SetConv2dTransposeInput();
138 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
139 SetPadParam();
140
141 m_paramsIndex = m_params;
142 m_inputsIndex = m_inputs;
143 EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
144 EXPECT_EQ(OH_NN_OPERATION_FORBIDDEN, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
145 }
146
147 /**
148 * @tc.name: conv2dtranpose_build_pad_003
149 * @tc.desc: Verify the missing input of the build function
150 * @tc.type: FUNC
151 */
152 HWTEST_F(Conv2DTransposeBuilderTest, conv2dtranpose_build_pad_003, TestSize.Level1)
153 {
154 m_inputs = {0};
155 m_outputs = {1};
156 m_params = {2, 3, 4, 5, 6, 7};
157
158 SetConv2dTransposeInput();
159 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
160 SetPadParam();
161
162 m_paramsIndex = m_params;
163 m_inputsIndex = m_inputs;
164 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
165 }
166
167 /**
168 * @tc.name: conv2dtranpose_build_pad_004
169 * @tc.desc: Verify the missing output of the build function
170 * @tc.type: FUNC
171 */
172 HWTEST_F(Conv2DTransposeBuilderTest, conv2dtranpose_build_pad_004, TestSize.Level1)
173 {
174 m_inputs = {0, 1, 2};
175 m_outputs = {};
176 m_params = {3, 4, 5, 6, 7, 8};
177
178 SetConv2dTransposeInput();
179 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
180 SetPadParam();
181
182 m_paramsIndex = m_params;
183 m_inputsIndex = m_inputs;
184 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
185 }
186
187 /**
188 * @tc.name: conv2dtranpose_build_pad_005
189 * @tc.desc: Verify the inputIndex out of bounds of the build function
190 * @tc.type: FUNC
191 */
192 HWTEST_F(Conv2DTransposeBuilderTest, conv2dtranpose_build_pad_005, TestSize.Level1)
193 {
194 m_inputs = {0, 1, 10};
195 m_outputs = {3};
196 m_params = {4, 5, 6, 7, 8, 9};
197
198 SetConv2dTransposeInput();
199 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
200 SetPadParam();
201
202 m_paramsIndex = m_params;
203 m_inputsIndex = m_inputs;
204 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
205 }
206
207 /**
208 * @tc.name: conv2dtranpose_build_pad_006
209 * @tc.desc: Verify the outputIndex out of bounds of the build function
210 * @tc.type: FUNC
211 */
212 HWTEST_F(Conv2DTransposeBuilderTest, conv2dtranpose_build_pad_006, TestSize.Level1)
213 {
214 m_inputs = {0, 1, 2};
215 m_outputs = {10};
216 m_params = {4, 5, 6, 7, 8, 9};;
217
218 SetConv2dTransposeInput();
219 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
220 SetPadParam();
221
222 m_paramsIndex = m_params;
223 m_inputsIndex = m_inputs;
224 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
225 }
226
227 /**
228 * @tc.name: conv2dtranpose_build_pad_007
229 * @tc.desc: Verify the invalid stride of the build function
230 * @tc.type: FUNC
231 */
232 HWTEST_F(Conv2DTransposeBuilderTest, conv2dtranpose_build_pad_007, TestSize.Level1)
233 {
234 SetConv2dTransposeInput();
235 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
236 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT32, m_stride_dim, nullptr,
237 OH_NN_CONV2D_TRANSPOSE_STRIDES);
238 int32_t* strideValue = new (std::nothrow) int32_t[2]{1, 1};
239 EXPECT_NE(nullptr, strideValue);
240
241 tensor->SetBuffer(strideValue, 2 * sizeof(int32_t));
242 m_allTensors.emplace_back(tensor);
243
244 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_DILATION);
245 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_PAD);
246 SetOutPaddings(OH_NN_INT64, m_outpaddings_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_OUTPUT_PADDINGS);
247 SetGroup(OH_NN_INT64, m_param_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_GROUP);
248 SetActivation(OH_NN_INT8, m_param_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_ACTIVATION_TYPE);
249 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
250 }
251
252 /**
253 * @tc.name: conv2dtranpose_build_pad_008
254 * @tc.desc: Verify the invalid dilation of the build function
255 * @tc.type: FUNC
256 */
257 HWTEST_F(Conv2DTransposeBuilderTest, conv2dtranpose_build_pad_008, TestSize.Level1)
258 {
259 SetConv2dTransposeInput();
260 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
261
262 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_STRIDES);
263 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT32, m_dilation_dim, nullptr,
264 OH_NN_CONV2D_TRANSPOSE_DILATION);
265 int32_t* dilationValue = new (std::nothrow) int32_t[2]{1, 1};
266 EXPECT_NE(nullptr, dilationValue);
267
268 tensor->SetBuffer(dilationValue, 2 * sizeof(int32_t));
269 m_allTensors.emplace_back(tensor);
270
271 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_PAD);
272 SetOutPaddings(OH_NN_INT64, m_outpaddings_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_OUTPUT_PADDINGS);
273 SetGroup(OH_NN_INT64, m_param_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_GROUP);
274 SetActivation(OH_NN_INT8, m_param_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_ACTIVATION_TYPE);
275 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
276 }
277
278 /**
279 * @tc.name: conv2dtranpose_build_pad_009
280 * @tc.desc: Verify the invalid pad of the build function
281 * @tc.type: FUNC
282 */
283 HWTEST_F(Conv2DTransposeBuilderTest, conv2dtranpose_build_pad_009, TestSize.Level1)
284 {
285 SetConv2dTransposeInput();
286 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
287
288 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_STRIDES);
289 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_DILATION);
290 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT32, m_pad_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_PAD);
291 int32_t* padValue = new (std::nothrow) int32_t[4]{1, 1, 1, 1};
292 EXPECT_NE(nullptr, padValue);
293
294 tensor->SetBuffer(padValue, 4 * sizeof(int32_t));
295 m_allTensors.emplace_back(tensor);
296
297 SetOutPaddings(OH_NN_INT64, m_outpaddings_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_OUTPUT_PADDINGS);
298 SetGroup(OH_NN_INT64, m_param_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_GROUP);
299 SetActivation(OH_NN_INT8, m_param_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_ACTIVATION_TYPE);
300 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
301 }
302
303 /**
304 * @tc.name: conv2dtranpose_build_pad_010
305 * @tc.desc: Verify the invalid outpaddings of the build function
306 * @tc.type: FUNC
307 */
308 HWTEST_F(Conv2DTransposeBuilderTest, conv2dtranpose_build_pad_010, TestSize.Level1)
309 {
310 SetConv2dTransposeInput();
311 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
312
313 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_STRIDES);
314 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_DILATION);
315 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_PAD);
316
317 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT32, m_outpaddings_dim, nullptr,
318 OH_NN_CONV2D_TRANSPOSE_OUTPUT_PADDINGS);
319
320 int32_t* outPaddingsTypeInvalid = new (std::nothrow) int32_t(0);
321 EXPECT_NE(nullptr, outPaddingsTypeInvalid);
322 tensor->SetBuffer(outPaddingsTypeInvalid, sizeof(int32_t));
323 m_allTensors.emplace_back(tensor);
324
325 SetGroup(OH_NN_INT64, m_param_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_GROUP);
326 SetActivation(OH_NN_INT8, m_param_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_ACTIVATION_TYPE);
327 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
328 }
329
330 /**
331 * @tc.name: conv2dtranpose_build_pad_011
332 * @tc.desc: Verify the invalid group of the build function
333 * @tc.type: FUNC
334 */
335 HWTEST_F(Conv2DTransposeBuilderTest, conv2dtranpose_build_pad_011, TestSize.Level1)
336 {
337 SetConv2dTransposeInput();
338 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
339 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_STRIDES);
340 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_DILATION);
341 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_PAD);
342 SetOutPaddings(OH_NN_INT64, m_outpaddings_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_OUTPUT_PADDINGS);
343
344 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT32, m_param_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_GROUP);
345 int32_t* groupValue = new (std::nothrow) int32_t(0);
346 EXPECT_NE(nullptr, groupValue);
347
348 tensor->SetBuffer(groupValue, sizeof(int32_t));
349 m_allTensors.emplace_back(tensor);
350 SetActivation(OH_NN_INT8, m_param_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_ACTIVATION_TYPE);
351 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
352 }
353
354 /**
355 * @tc.name: conv2dtranpose_build_pad_012
356 * @tc.desc: Verify the invalid activation of the build function
357 * @tc.type: FUNC
358 */
359 HWTEST_F(Conv2DTransposeBuilderTest, conv2dtranpose_build_pad_012, TestSize.Level1)
360 {
361 SetConv2dTransposeInput();
362 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
363
364 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_STRIDES);
365 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_DILATION);
366 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_PAD);
367 SetOutPaddings(OH_NN_INT64, m_outpaddings_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_OUTPUT_PADDINGS);
368 SetGroup(OH_NN_INT64, m_param_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_GROUP);
369
370 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT32, m_param_dim, nullptr,
371 OH_NN_CONV2D_TRANSPOSE_ACTIVATION_TYPE);
372 int32_t* activationValue = new (std::nothrow) int32_t(0);
373 EXPECT_NE(nullptr, activationValue);
374
375 tensor->SetBuffer(activationValue, sizeof(int32_t));
376 m_allTensors.emplace_back(tensor);
377 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
378 }
379
380 /**
381 * @tc.name: conv2dtranpose_build_pad_013
382 * @tc.desc: Verify the group scalar length of the build function
383 * @tc.type: FUNC
384 */
385 HWTEST_F(Conv2DTransposeBuilderTest, conv2dtranpose_build_pad_013, TestSize.Level1)
386 {
387 SetConv2dTransposeInput();
388 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
389
390 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_STRIDES);
391 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_DILATION);
392 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_PAD);
393 SetOutPaddings(OH_NN_INT64, m_outpaddings_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_OUTPUT_PADDINGS);
394
395 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT64, m_outpaddings_dim, nullptr,
396 OH_NN_CONV2D_TRANSPOSE_GROUP);
397 int64_t* groupValue = new (std::nothrow) int64_t[2]{0, 0};
398 EXPECT_NE(nullptr, groupValue);
399
400 tensor->SetBuffer(groupValue, 2 * sizeof(int64_t));
401 m_allTensors.emplace_back(tensor);
402 SetActivation(OH_NN_INT8, m_param_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_ACTIVATION_TYPE);
403 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
404 }
405
406 /**
407 * @tc.name: conv2dtranpose_build_pad_014
408 * @tc.desc: Verify the activation scalar length of the build function
409 * @tc.type: FUNC
410 */
411 HWTEST_F(Conv2DTransposeBuilderTest, conv2dtranpose_build_pad_014, TestSize.Level1)
412 {
413 SetConv2dTransposeInput();
414 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
415
416 SetStride(OH_NN_INT64, m_stride_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_STRIDES);
417 SetDilation(OH_NN_INT64, m_dilation_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_DILATION);
418 SetPad(OH_NN_INT64, m_pad_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_PAD);
419 SetOutPaddings(OH_NN_INT64, m_outpaddings_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_OUTPUT_PADDINGS);
420 SetGroup(OH_NN_INT64, m_param_dim, nullptr, OH_NN_CONV2D_TRANSPOSE_GROUP);
421
422 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT8, m_outpaddings_dim, nullptr,
423 OH_NN_CONV2D_TRANSPOSE_ACTIVATION_TYPE);
424 int8_t* activationValue = new (std::nothrow) int8_t[2]{0, 0};
425 EXPECT_NE(nullptr, activationValue);
426 tensor->SetBuffer(activationValue, 2 * sizeof(int8_t));
427 m_allTensors.emplace_back(tensor);
428 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
429 }
430
431 /**
432 * @tc.name: conv2dtranpose_getprimitive_padmode_001
433 * @tc.desc: Verify the behavior of the GetPrimitive function
434 * @tc.type: FUNC
435 */
436 HWTEST_F(Conv2DTransposeBuilderTest, conv2dtranpose_getprimitive_padmode_001, TestSize.Level1)
437 {
438 SetConv2dTransposeInput();
439 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
440 SetPadParam();
441
442 m_paramsIndex = m_params;
443 m_inputsIndex = m_inputs;
444 EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
445
446 LiteGraphTensorPtr primitive = m_builder.GetPrimitive();
447 LiteGraphTensorPtr expectPrimitive(nullptr, DestroyLiteGraphPrimitive);
448 EXPECT_NE(expectPrimitive, primitive);
449
450 std::vector<int64_t> returnStrides = mindspore::lite::MindIR_Conv2dTransposeFusion_GetStride(primitive.get());
451 std::vector<int64_t> strideValueTest{1, 1};
452 std::vector<int64_t> returnDliation = mindspore::lite::MindIR_Conv2dTransposeFusion_GetDilation(primitive.get());
453 std::vector<int64_t> dilationValueTest{1, 1};
454 std::vector<int64_t> returnPad = mindspore::lite::MindIR_Conv2dTransposeFusion_GetPadList(primitive.get());
455 std::vector<int64_t> padValueTest{1, 1, 1, 1};
456 int returnGroup = mindspore::lite::MindIR_Conv2dTransposeFusion_GetGroup(primitive.get());
457 EXPECT_EQ(0, returnGroup);
458
459 std::vector<int64_t> outPaddingReturn =
460 mindspore::lite::MindIR_Conv2dTransposeFusion_GetOutputPaddings(primitive.get());
461 std::vector<int64_t> outPaddingTest{0, 0};
462 EXPECT_EQ(outPaddingTest, outPaddingReturn);
463
464 int returnActivation = mindspore::lite::MindIR_Conv2dTransposeFusion_GetActivationType(primitive.get());
465 EXPECT_EQ(0, returnActivation);
466 }
467
468 /**
469 * @tc.name: conv2dtranpose_getprimitive_padmode_002
470 * @tc.desc: Verify the behavior of the GetPrimitive function
471 * @tc.type: FUNC
472 */
473 HWTEST_F(Conv2DTransposeBuilderTest, conv2dtranpose_getprimitive_padmode_002, TestSize.Level1)
474 {
475 SetConv2dTransposeInput();
476 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
477 SetPadParam();
478
479 m_paramsIndex = m_params;
480 m_inputsIndex = m_inputs;
481
482 LiteGraphTensorPtr primitive = m_builder.GetPrimitive();
483 LiteGraphTensorPtr expectPrimitive(nullptr, DestroyLiteGraphPrimitive);
484 EXPECT_EQ(expectPrimitive, primitive);
485 }
486 } // namespace UnitTest
487 } // namespace NeuralNetworkRuntime
488 } // namespace OHOS
489