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/resize_bilinear_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 ResizeBilinearBuilderTest : public OpsTest {
28 public:
29 void SetUp() override;
30 void TearDown() override;
31
32 protected:
33 void SaveHeightTensor(OH_NN_DataType dataType, const std::vector<int32_t> &dim,
34 const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
35 void SaveWidthTensor(OH_NN_DataType dataType, const std::vector<int32_t> &dim,
36 const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
37 void SaveRatioTensor(OH_NN_DataType dataType, const std::vector<int32_t> &dim,
38 const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
39 void SaveModeTensor(OH_NN_DataType dataType, const std::vector<int32_t> &dim,
40 const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
41 void SaveOutsideTensor(OH_NN_DataType dataType, const std::vector<int32_t> &dim,
42 const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
43 void SetParameterTensor();
44
45 protected:
46 ResizeBilinearBuilder m_builder;
47
48 std::shared_ptr<NNTensor> heightTensor {nullptr};
49 std::shared_ptr<NNTensor> widthTensor {nullptr};
50 std::shared_ptr<NNTensor> ratioTensor {nullptr};
51 std::shared_ptr<NNTensor> modeTensor {nullptr};
52 std::shared_ptr<NNTensor> outsideTensor {nullptr};
53
54 std::vector<uint32_t> m_inputs {0};
55 std::vector<uint32_t> m_outputs {1};
56 std::vector<uint32_t> m_params {2, 3, 4, 5, 6};
57 std::vector<int32_t> m_dim {1, 2, 2, 2};
58 std::vector<int32_t> m_paramDim {};
59 };
60
SetUp()61 void ResizeBilinearBuilderTest::SetUp() {}
62
TearDown()63 void ResizeBilinearBuilderTest::TearDown() {}
64
SaveHeightTensor(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)65 void ResizeBilinearBuilderTest::SaveHeightTensor(OH_NN_DataType dataType, const std::vector<int32_t> &dim,
66 const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
67 {
68 heightTensor = TransToNNTensor(dataType, dim, quantParam, type);
69 int64_t *heightValue = new (std::nothrow) int64_t(1);
70 EXPECT_NE(nullptr, heightValue);
71 heightTensor->SetBuffer(heightValue, sizeof(int64_t));
72 m_allTensors.emplace_back(heightTensor);
73 }
74
SaveWidthTensor(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)75 void ResizeBilinearBuilderTest::SaveWidthTensor(OH_NN_DataType dataType, const std::vector<int32_t> &dim,
76 const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
77 {
78 widthTensor = TransToNNTensor(dataType, dim, quantParam, type);
79 int64_t *widthValue = new (std::nothrow) int64_t(1);
80 EXPECT_NE(nullptr, widthValue);
81 widthTensor->SetBuffer(widthValue, sizeof(int64_t));
82 m_allTensors.emplace_back(widthTensor);
83 }
84
SaveRatioTensor(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)85 void ResizeBilinearBuilderTest::SaveRatioTensor(OH_NN_DataType dataType, const std::vector<int32_t> &dim,
86 const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
87 {
88 ratioTensor = TransToNNTensor(dataType, dim, quantParam, type);
89 bool *ratioValue = new (std::nothrow) bool(true);
90 EXPECT_NE(nullptr, ratioValue);
91 ratioTensor->SetBuffer(ratioValue, sizeof(bool));
92 m_allTensors.emplace_back(ratioTensor);
93 }
94
SaveModeTensor(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)95 void ResizeBilinearBuilderTest::SaveModeTensor(OH_NN_DataType dataType, const std::vector<int32_t> &dim,
96 const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
97 {
98 modeTensor = TransToNNTensor(dataType, dim, quantParam, type);
99 int8_t *modeValue = new (std::nothrow) int8_t(1);
100 EXPECT_NE(nullptr, modeValue);
101 modeTensor->SetBuffer(modeValue, sizeof(int8_t));
102 m_allTensors.emplace_back(modeTensor);
103 }
104
SaveOutsideTensor(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)105 void ResizeBilinearBuilderTest::SaveOutsideTensor(OH_NN_DataType dataType, const std::vector<int32_t> &dim,
106 const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
107 {
108 outsideTensor = TransToNNTensor(dataType, dim, quantParam, type);
109 int64_t *outsideValue = new (std::nothrow) int64_t(1);
110 EXPECT_NE(nullptr, outsideValue);
111 outsideTensor->SetBuffer(outsideValue, sizeof(int64_t));
112 m_allTensors.emplace_back(outsideTensor);
113 }
114
SetParameterTensor()115 void ResizeBilinearBuilderTest::SetParameterTensor()
116 {
117 SaveHeightTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_HEIGHT);
118 SaveWidthTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_WIDTH);
119 SaveRatioTensor(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_PRESERVE_ASPECT_RATIO);
120 SaveModeTensor(OH_NN_INT8, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_COORDINATE_TRANSFORM_MODE);
121 SaveOutsideTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_EXCLUDE_OUTSIDE);
122 }
123
124 /**
125 * @tc.name: resizebilinear_build_001
126 * @tc.desc: Provide normal input, output, and parameters to verify the normal behavior of the Build function
127 * @tc.type: FUNC
128 */
129 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_001, TestSize.Level0)
130 {
131 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
132 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
133
134 SetParameterTensor();
135
136 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
137 EXPECT_EQ(OH_NN_SUCCESS, ret);
138 }
139
140 /**
141 * @tc.name: resizebilinear_build_002
142 * @tc.desc: Call Build func twice to verify the abnormal behavior of the Build function
143 * @tc.type: FUNC
144 */
145 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_002, TestSize.Level0)
146 {
147 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
148 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
149
150 SetParameterTensor();
151
152 EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors));
153 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
154 EXPECT_EQ(OH_NN_OPERATION_FORBIDDEN, ret);
155 }
156
157 /**
158 * @tc.name: resizebilinear_build_003
159 * @tc.desc: Provide one more than normal input to verify the abnormal behavior of the Build function
160 * @tc.type: FUNC
161 */
162 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_003, TestSize.Level0)
163 {
164 m_inputs = {0, 1};
165 m_outputs = {2};
166
167 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
168 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
169
170 SetParameterTensor();
171
172 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
173 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
174 }
175
176 /**
177 * @tc.name: resizebilinear_build_004
178 * @tc.desc: Provide one more than normal output to verify the abnormal behavior of the Build function
179 * @tc.type: FUNC
180 */
181 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_004, TestSize.Level0)
182 {
183 m_outputs = {1, 2};
184
185 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
186 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
187
188 SetParameterTensor();
189
190 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
191 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
192 }
193
194 /**
195 * @tc.name: resizebilinear_build_005
196 * @tc.desc: Verify that the build function return a failed message with null allTensor
197 * @tc.type: FUNC
198 */
199 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_005, TestSize.Level0)
200 {
201 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputs, m_outputs, m_allTensors);
202 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
203 }
204
205 /**
206 * @tc.name: resizebilinear_build_006
207 * @tc.desc: Verify that the build function return a failed message without output tensor
208 * @tc.type: FUNC
209 */
210 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_006, TestSize.Level0)
211 {
212 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
213
214 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputs, m_allTensors);
215 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
216 }
217
218 /**
219 * @tc.name: resizebilinear_build_007
220 * @tc.desc: Verify that the build function return a failed message with invalided height's dataType
221 * @tc.type: FUNC
222 */
223 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_007, TestSize.Level0)
224 {
225 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
226 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
227
228 heightTensor = TransToNNTensor(OH_NN_INT32, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_HEIGHT);
229 int32_t heightValues = 1;
230 heightTensor->SetBuffer(&heightValues, sizeof(heightValues));
231 m_allTensors.emplace_back(heightTensor);
232
233 SaveWidthTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_WIDTH);
234 SaveRatioTensor(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_PRESERVE_ASPECT_RATIO);
235 SaveModeTensor(OH_NN_INT8, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_COORDINATE_TRANSFORM_MODE);
236 SaveOutsideTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_EXCLUDE_OUTSIDE);
237
238
239 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
240 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
241 heightTensor->SetBuffer(nullptr, 0);
242 }
243
244 /**
245 * @tc.name: resizebilinear_build_008
246 * @tc.desc: Verify that the build function return a failed message with invalided width's dataType
247 * @tc.type: FUNC
248 */
249 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_008, TestSize.Level0)
250 {
251 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
252 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
253
254 SaveHeightTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_HEIGHT);
255 SaveRatioTensor(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_PRESERVE_ASPECT_RATIO);
256 SaveModeTensor(OH_NN_INT8, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_COORDINATE_TRANSFORM_MODE);
257 SaveOutsideTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_EXCLUDE_OUTSIDE);
258
259
260 widthTensor = TransToNNTensor(OH_NN_INT32, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_WIDTH);
261 int32_t widthValues = 1;
262 widthTensor->SetBuffer(&widthValues, sizeof(widthValues));
263 m_allTensors.emplace_back(widthTensor);
264
265 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
266 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
267 widthTensor->SetBuffer(nullptr, 0);
268 }
269
270 /**
271 * @tc.name: resizebilinear_build_009
272 * @tc.desc: Verify that the build function return a failed message with invalided ratio's dataType
273 * @tc.type: FUNC
274 */
275 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_009, TestSize.Level0)
276 {
277 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
278 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
279
280 SaveHeightTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_HEIGHT);
281 SaveWidthTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_WIDTH);
282 SaveModeTensor(OH_NN_INT8, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_COORDINATE_TRANSFORM_MODE);
283 SaveOutsideTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_EXCLUDE_OUTSIDE);
284
285 ratioTensor = TransToNNTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_PRESERVE_ASPECT_RATIO);
286 int64_t ratioValues = 1;
287 ratioTensor->SetBuffer(&ratioValues, sizeof(ratioValues));
288 m_allTensors.emplace_back(ratioTensor);
289
290 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
291 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
292 ratioTensor->SetBuffer(nullptr, 0);
293 }
294
295 /**
296 * @tc.name: resizebilinear_build_010
297 * @tc.desc: Verify that the build function return a failed message with invalided mode's dataType
298 * @tc.type: FUNC
299 */
300 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_010, TestSize.Level0)
301 {
302 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
303 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
304
305 SaveHeightTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_HEIGHT);
306 SaveWidthTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_WIDTH);
307 SaveRatioTensor(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_PRESERVE_ASPECT_RATIO);
308 SaveOutsideTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_EXCLUDE_OUTSIDE);
309
310 modeTensor = TransToNNTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_COORDINATE_TRANSFORM_MODE);
311 int64_t modeValues = 1;
312 modeTensor->SetBuffer(&modeValues, sizeof(modeValues));
313 m_allTensors.emplace_back(modeTensor);
314
315 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
316 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
317 modeTensor->SetBuffer(nullptr, 0);
318 }
319
320 /**
321 * @tc.name: resizebilinear_build_011
322 * @tc.desc: Verify that the build function return a failed message with invalided outside's dataType
323 * @tc.type: FUNC
324 */
325 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_011, TestSize.Level0)
326 {
327 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
328 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
329
330 SaveHeightTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_HEIGHT);
331 SaveWidthTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_WIDTH);
332 SaveRatioTensor(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_PRESERVE_ASPECT_RATIO);
333 SaveModeTensor(OH_NN_INT8, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_COORDINATE_TRANSFORM_MODE);
334
335 outsideTensor = TransToNNTensor(OH_NN_INT32,
336 m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_EXCLUDE_OUTSIDE);
337 int32_t outsideValues = 1;
338 outsideTensor->SetBuffer(&outsideValues, sizeof(outsideValues));
339 m_allTensors.emplace_back(outsideTensor);
340
341 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
342 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
343 outsideTensor->SetBuffer(nullptr, 0);
344 }
345
346 /**
347 * @tc.name: resizebilinear_build_012
348 * @tc.desc: Verify that the build function return a failed message with invalided height's dimension
349 * @tc.type: FUNC
350 */
351 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_012, TestSize.Level0)
352 {
353 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
354 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
355
356 SaveWidthTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_WIDTH);
357 SaveRatioTensor(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_PRESERVE_ASPECT_RATIO);
358 SaveModeTensor(OH_NN_INT8, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_COORDINATE_TRANSFORM_MODE);
359 SaveOutsideTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_EXCLUDE_OUTSIDE);
360
361 std::vector<int32_t> heightDim = {2};
362 heightTensor = TransToNNTensor(OH_NN_INT64, heightDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_HEIGHT);
363 int64_t heightValues[2] = {1, 1};
364 heightTensor->SetBuffer(heightValues, 2 * sizeof(int64_t));
365 m_allTensors.emplace_back(heightTensor);
366
367 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
368 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
369 heightTensor->SetBuffer(nullptr, 0);
370 }
371
372 /**
373 * @tc.name: resizebilinear_build_013
374 * @tc.desc: Verify that the build function return a failed message with invalided width's dimension
375 * @tc.type: FUNC
376 */
377 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_013, TestSize.Level0)
378 {
379 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
380 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
381
382 SaveHeightTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_HEIGHT);
383 SaveRatioTensor(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_PRESERVE_ASPECT_RATIO);
384 SaveModeTensor(OH_NN_INT8, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_COORDINATE_TRANSFORM_MODE);
385 SaveOutsideTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_EXCLUDE_OUTSIDE);
386
387 std::vector<int32_t> widthDim = {2};
388 widthTensor = TransToNNTensor(OH_NN_INT64, widthDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_WIDTH);
389 int64_t widthValues[2] = {1, 1};
390 widthTensor->SetBuffer(widthValues, 2 * sizeof(int64_t));
391 m_allTensors.emplace_back(widthTensor);
392
393 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
394 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
395 widthTensor->SetBuffer(nullptr, 0);
396 }
397
398 /**
399 * @tc.name: resizebilinear_build_014
400 * @tc.desc: Verify that the build function return a failed message with invalided ratio's dimension
401 * @tc.type: FUNC
402 */
403 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_014, TestSize.Level0)
404 {
405 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
406 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
407
408 SaveHeightTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_HEIGHT);
409 SaveWidthTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_WIDTH);
410 SaveModeTensor(OH_NN_INT8, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_COORDINATE_TRANSFORM_MODE);
411 SaveOutsideTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_EXCLUDE_OUTSIDE);
412
413 std::vector<int32_t> ratioDim = {2};
414 ratioTensor = TransToNNTensor(OH_NN_BOOL,
415 ratioDim, nullptr, OH_NN_RESIZE_BILINEAR_PRESERVE_ASPECT_RATIO);
416 bool ratioValues[2] = {true, true};
417 ratioTensor->SetBuffer(ratioValues, 2 * sizeof(bool));
418 m_allTensors.emplace_back(ratioTensor);
419
420 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
421 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
422 ratioTensor->SetBuffer(nullptr, 0);
423 }
424
425 /**
426 * @tc.name: resizebilinear_build_015
427 * @tc.desc: Verify that the build function return a failed message with invalided mode's dimension
428 * @tc.type: FUNC
429 */
430 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_015, TestSize.Level0)
431 {
432 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
433 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
434
435 SaveHeightTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_HEIGHT);
436 SaveWidthTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_WIDTH);
437 SaveRatioTensor(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_PRESERVE_ASPECT_RATIO);
438 SaveOutsideTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_EXCLUDE_OUTSIDE);
439
440
441 std::vector<int32_t> modeDim = {2};
442 modeTensor = TransToNNTensor(OH_NN_INT8,
443 modeDim, nullptr, OH_NN_RESIZE_BILINEAR_COORDINATE_TRANSFORM_MODE);
444 int8_t modeValues[2] = {1, 1};
445 modeTensor->SetBuffer(modeValues, 2 * sizeof(int8_t));
446 m_allTensors.emplace_back(modeTensor);
447
448 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
449 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
450 modeTensor->SetBuffer(nullptr, 0);
451 }
452
453 /**
454 * @tc.name: resizebilinear_build_016
455 * @tc.desc: Verify that the build function return a failed message with invalided outside's dimension
456 * @tc.type: FUNC
457 */
458 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_016, TestSize.Level0)
459 {
460 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
461 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
462
463 SaveHeightTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_HEIGHT);
464 SaveWidthTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_WIDTH);
465 SaveRatioTensor(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_PRESERVE_ASPECT_RATIO);
466 SaveModeTensor(OH_NN_INT8, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_COORDINATE_TRANSFORM_MODE);
467
468 std::vector<int32_t> outsideDim = {2};
469 outsideTensor = TransToNNTensor(OH_NN_INT64,
470 outsideDim, nullptr, OH_NN_RESIZE_BILINEAR_EXCLUDE_OUTSIDE);
471 int64_t outsideValues[2] = {1, 1};
472 outsideTensor->SetBuffer(outsideValues, 2 * sizeof(int64_t));
473 m_allTensors.emplace_back(outsideTensor);
474
475 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
476 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
477 outsideTensor->SetBuffer(nullptr, 0);
478 }
479
480 /**
481 * @tc.name: resizebilinear_build_017
482 * @tc.desc: Verify that the build function return a failed message with invalided parameter
483 * @tc.type: FUNC
484 */
485 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_017, TestSize.Level0)
486 {
487 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
488 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
489
490 SaveHeightTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_HEIGHT);
491 SaveWidthTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_WIDTH);
492 SaveRatioTensor(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_PRESERVE_ASPECT_RATIO);
493 SaveModeTensor(OH_NN_INT8, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_COORDINATE_TRANSFORM_MODE);
494 SaveOutsideTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_QUANT_DTYPE_CAST_SRC_T);
495
496 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
497 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
498 }
499
500 /**
501 * @tc.name: resizebilinear_build_018
502 * @tc.desc: Verify that the build function return a failed message with empty height's buffer
503 * @tc.type: FUNC
504 */
505 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_018, TestSize.Level0)
506 {
507 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
508 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
509
510 heightTensor = TransToNNTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_HEIGHT);
511 m_allTensors.emplace_back(heightTensor);
512
513 SaveWidthTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_WIDTH);
514 SaveRatioTensor(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_PRESERVE_ASPECT_RATIO);
515 SaveModeTensor(OH_NN_INT8, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_COORDINATE_TRANSFORM_MODE);
516 SaveOutsideTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_EXCLUDE_OUTSIDE);
517
518 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
519 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
520 heightTensor->SetBuffer(nullptr, 0);
521 }
522
523 /**
524 * @tc.name: resizebilinear_build_019
525 * @tc.desc: Verify that the build function return a failed message with empty width's buffer
526 * @tc.type: FUNC
527 */
528 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_019, TestSize.Level0)
529 {
530 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
531 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
532
533 SaveHeightTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_HEIGHT);
534 SaveRatioTensor(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_PRESERVE_ASPECT_RATIO);
535 SaveModeTensor(OH_NN_INT8, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_COORDINATE_TRANSFORM_MODE);
536 SaveOutsideTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_EXCLUDE_OUTSIDE);
537
538 widthTensor = TransToNNTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_WIDTH);
539 m_allTensors.emplace_back(widthTensor);
540
541 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
542 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
543 widthTensor->SetBuffer(nullptr, 0);
544 }
545
546 /**
547 * @tc.name: resizebilinear_build_020
548 * @tc.desc: Verify that the build function return a failed message with empty ratio's buffer
549 * @tc.type: FUNC
550 */
551 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_020, TestSize.Level0)
552 {
553 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
554 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
555
556 SaveHeightTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_HEIGHT);
557 SaveWidthTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_WIDTH);
558 SaveModeTensor(OH_NN_INT8, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_COORDINATE_TRANSFORM_MODE);
559 SaveOutsideTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_EXCLUDE_OUTSIDE);
560
561 ratioTensor = TransToNNTensor(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_PRESERVE_ASPECT_RATIO);
562 m_allTensors.emplace_back(ratioTensor);
563
564 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
565 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
566 ratioTensor->SetBuffer(nullptr, 0);
567 }
568
569 /**
570 * @tc.name: resizebilinear_build_021
571 * @tc.desc: Verify that the build function return a failed message with empty mode's buffer
572 * @tc.type: FUNC
573 */
574 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_021, TestSize.Level0)
575 {
576 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
577 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
578
579 SaveHeightTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_HEIGHT);
580 SaveWidthTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_WIDTH);
581 SaveRatioTensor(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_PRESERVE_ASPECT_RATIO);
582 SaveOutsideTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_EXCLUDE_OUTSIDE);
583
584 modeTensor = TransToNNTensor(OH_NN_INT8, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_COORDINATE_TRANSFORM_MODE);
585 m_allTensors.emplace_back(modeTensor);
586
587 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
588 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
589 modeTensor->SetBuffer(nullptr, 0);
590 }
591
592 /**
593 * @tc.name: resizebilinear_build_022
594 * @tc.desc: Verify that the build function return a failed message with empty outside's buffer
595 * @tc.type: FUNC
596 */
597 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_build_022, TestSize.Level0)
598 {
599 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
600 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
601
602 SaveHeightTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_HEIGHT);
603 SaveWidthTensor(OH_NN_INT64, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_NEW_WIDTH);
604 SaveRatioTensor(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_PRESERVE_ASPECT_RATIO);
605 SaveModeTensor(OH_NN_INT8, m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_COORDINATE_TRANSFORM_MODE);
606
607 outsideTensor = TransToNNTensor(OH_NN_INT64,
608 m_paramDim, nullptr, OH_NN_RESIZE_BILINEAR_EXCLUDE_OUTSIDE);
609 m_allTensors.emplace_back(outsideTensor);
610
611 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
612 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
613 outsideTensor->SetBuffer(nullptr, 0);
614 }
615
616 /**
617 * @tc.name: resizebilinear_get_primitive_001
618 * @tc.desc: Verify the GetPrimitive function return nullptr
619 * @tc.type: FUNC
620 */
621 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_get_primitive_001, TestSize.Level0)
622 {
623 LiteGraphTensorPtr primitive = m_builder.GetPrimitive();
624 LiteGraphTensorPtr expectPrimitive = {nullptr, DestroyLiteGraphPrimitive};
625 EXPECT_EQ(primitive, expectPrimitive);
626 }
627
628 /**
629 * @tc.name: resizebilinear_get_primitive_002
630 * @tc.desc: Verify the normal params return behavior of the getprimitive function
631 * @tc.type: FUNC
632 */
633 HWTEST_F(ResizeBilinearBuilderTest, resizebilinear_get_primitive_002, TestSize.Level0)
634 {
635 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_dim, nullptr);
636 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_dim, nullptr);
637
638 SetParameterTensor();
639
640 EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors));
641 LiteGraphTensorPtr primitive = m_builder.GetPrimitive();
642 LiteGraphTensorPtr expectPrimitive = {nullptr, DestroyLiteGraphPrimitive};
643 EXPECT_NE(primitive, expectPrimitive);
644
645 int64_t heightValue = 1;
646 int64_t widthValue = 1;
647 bool ratioValue = true;
648 int8_t modeValue = 1;
649 int64_t outsideValue = 1;
650
651 int64_t heightReturn = mindspore::lite::MindIR_Resize_GetNewHeight(primitive.get());
652 EXPECT_EQ(heightReturn, heightValue);
653 int64_t widthReturn = mindspore::lite::MindIR_Resize_GetNewWidth(primitive.get());
654 EXPECT_EQ(widthReturn, widthValue);
655 bool ratioReturn = mindspore::lite::MindIR_Resize_GetPreserveAspectRatio(primitive.get());
656 EXPECT_EQ(ratioReturn, ratioValue);
657 int8_t modeReturn = mindspore::lite::MindIR_Resize_GetCoordinateTransformMode(primitive.get());
658 EXPECT_EQ(modeReturn, modeValue);
659 int64_t outsideReturn = mindspore::lite::MindIR_Resize_GetExcludeOutside(primitive.get());
660 EXPECT_EQ(outsideReturn, outsideValue);
661 }
662 } // namespace UnitTest
663 } // namespace NeuralNetworkRuntime
664 } // namespace OHOS