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/batch_to_space_nd_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 BatchToSpaceNDBuilderTest : public OpsTest {
28 public:
29 void SetUp() override;
30 void TearDown() override;
31
32 void SetBlockSize(OH_NN_DataType dataType,
33 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
34 void SetCrops(OH_NN_DataType dataType,
35 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
36
37 public:
38 BatchToSpaceNDBuilder m_builder;
39 std::vector<uint32_t> m_inputs{0};
40 std::vector<uint32_t> m_outputs{1};
41 std::vector<uint32_t> m_params{2, 3};
42 std::vector<int32_t> m_input_dim{4, 1, 1, 1};
43 std::vector<int32_t> m_output_dim{1, 2, 2, 1};
44 std::vector<int32_t> m_block_dim{2};
45 std::vector<int32_t> m_crops_dim{2, 2};
46 };
47
SetUp()48 void BatchToSpaceNDBuilderTest::SetUp() {}
49
TearDown()50 void BatchToSpaceNDBuilderTest::TearDown() {}
51
SetBlockSize(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)52 void BatchToSpaceNDBuilderTest::SetBlockSize(OH_NN_DataType dataType,
53 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
54 {
55 std::shared_ptr<NNTensor> tensor = TransToNNTensor(dataType, dim, quantParam, type);
56 int32_t blockNum = 2;
57 int64_t* blockSizeValue = new (std::nothrow) int64_t[2]{2, 2};
58 EXPECT_NE(nullptr, blockSizeValue);
59 tensor->SetBuffer(blockSizeValue, sizeof(int64_t) * blockNum);
60 m_allTensors.emplace_back(tensor);
61 }
62
SetCrops(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)63 void BatchToSpaceNDBuilderTest::SetCrops(OH_NN_DataType dataType,
64 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
65 {
66 int32_t cropsNum = 4;
67 std::shared_ptr<NNTensor> tensor = TransToNNTensor(dataType, dim, quantParam, type);
68 int64_t* cropsValue = new (std::nothrow) int64_t[4]{0, 0, 0, 0};
69 EXPECT_NE(nullptr, cropsValue);
70 tensor->SetBuffer(cropsValue, sizeof(int64_t) * cropsNum);
71 m_allTensors.emplace_back(tensor);
72 }
73
74 /**
75 * @tc.name: batch_to_space_nd_build_001
76 * @tc.desc: Verify the success of the build function
77 * @tc.type: FUNC
78 */
79 HWTEST_F(BatchToSpaceNDBuilderTest, batch_to_space_nd_build_001, TestSize.Level1)
80 {
81 m_paramsIndex = m_params;
82 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
83 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
84
85 SetBlockSize(OH_NN_INT64, m_block_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_BLOCKSIZE);
86 SetCrops(OH_NN_INT64, m_crops_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_CROPS);
87 EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
88 }
89
90 /**
91 * @tc.name: batch_to_space_nd_build_002
92 * @tc.desc: Verify the forbidden of the build function
93 * @tc.type: FUNC
94 */
95 HWTEST_F(BatchToSpaceNDBuilderTest, batch_to_space_nd_build_002, TestSize.Level1)
96 {
97 m_paramsIndex = m_params;
98 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
99 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
100
101 SetBlockSize(OH_NN_INT64, m_block_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_BLOCKSIZE);
102 SetCrops(OH_NN_INT64, m_crops_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_CROPS);
103 EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
104 EXPECT_EQ(OH_NN_OPERATION_FORBIDDEN, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
105 }
106
107 /**
108 * @tc.name: batch_to_space_nd_build_003
109 * @tc.desc: Verify the missing input of the build function
110 * @tc.type: FUNC
111 */
112 HWTEST_F(BatchToSpaceNDBuilderTest, batch_to_space_nd_build_003, TestSize.Level1)
113 {
114 m_params = {1, 2};
115 m_paramsIndex = m_params;
116 m_inputs = {};
117 m_outputs = {0};
118
119 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
120 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
121
122 SetBlockSize(OH_NN_INT64, m_block_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_BLOCKSIZE);
123 SetCrops(OH_NN_INT64, m_crops_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_CROPS);
124 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
125 }
126
127 /**
128 * @tc.name: batch_to_space_nd_build_004
129 * @tc.desc: Verify the missing output of the build function
130 * @tc.type: FUNC
131 */
132 HWTEST_F(BatchToSpaceNDBuilderTest, batch_to_space_nd_build_004, TestSize.Level1)
133 {
134 m_inputs = {};
135 m_outputs = {0};
136 m_params = {1, 2};
137
138 m_paramsIndex = m_params;
139 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
140 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
141
142 SetBlockSize(OH_NN_INT64, m_block_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_BLOCKSIZE);
143 SetCrops(OH_NN_INT64, m_crops_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_CROPS);
144 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
145 }
146
147 /**
148 * @tc.name: batch_to_space_nd_build_005
149 * @tc.desc: Verify the inputIndex out of bounds of the build function
150 * @tc.type: FUNC
151 */
152 HWTEST_F(BatchToSpaceNDBuilderTest, batch_to_space_nd_build_005, TestSize.Level1)
153 {
154 m_inputs = {6};
155 m_outputs = {1};
156 m_params = {2, 3};
157
158 m_paramsIndex = m_params;
159 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
160 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
161
162 SetBlockSize(OH_NN_INT64, m_block_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_BLOCKSIZE);
163 SetCrops(OH_NN_INT64, m_crops_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_CROPS);
164 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
165 }
166
167 /**
168 * @tc.name: batch_to_space_nd_build_006
169 * @tc.desc: Verify the outputIndex out of bounds of the build function
170 * @tc.type: FUNC
171 */
172 HWTEST_F(BatchToSpaceNDBuilderTest, batch_to_space_nd_build_006, TestSize.Level1)
173 {
174 m_inputs = {0};
175 m_outputs = {6};
176 m_params = {2, 3};
177
178 m_paramsIndex = m_params;
179 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
180 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
181
182 SetBlockSize(OH_NN_INT64, m_block_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_BLOCKSIZE);
183 SetCrops(OH_NN_INT64, m_crops_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_CROPS);
184 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
185 }
186
187 /**
188 * @tc.name: batch_to_space_nd_build_007
189 * @tc.desc: Verify the invalid crops of the build function
190 * @tc.type: FUNC
191 */
192 HWTEST_F(BatchToSpaceNDBuilderTest, batch_to_space_nd_build_007, TestSize.Level1)
193 {
194 m_paramsIndex = m_params;
195 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
196 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
197
198 SetBlockSize(OH_NN_INT64, m_block_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_BLOCKSIZE);
199 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT32, m_crops_dim, nullptr,
200 OH_NN_BATCH_TO_SPACE_ND_CROPS);
201 int32_t cropsNum = 4;
202 int32_t* cropsValue = new (std::nothrow) int32_t[4]{0, 0, 0, 0};
203 EXPECT_NE(nullptr, cropsValue);
204
205 tensor->SetBuffer(cropsValue, sizeof(int32_t) * cropsNum);
206 m_allTensors.emplace_back(tensor);
207 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
208 }
209
210 /**
211 * @tc.name: batch_to_space_nd_build_008
212 * @tc.desc: Verify the invalid blocksize of the build function
213 * @tc.type: FUNC
214 */
215 HWTEST_F(BatchToSpaceNDBuilderTest, batch_to_space_nd_build_008, TestSize.Level1)
216 {
217 m_paramsIndex = m_params;
218 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
219 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
220
221 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT32, m_block_dim, nullptr,
222 OH_NN_BATCH_TO_SPACE_ND_BLOCKSIZE);
223 int32_t blockNum = 2;
224 int32_t* blockSizeValue = new (std::nothrow) int32_t[2]{2, 2};
225 EXPECT_NE(nullptr, blockSizeValue);
226 tensor->SetBuffer(blockSizeValue, sizeof(int32_t) * blockNum);
227 m_allTensors.emplace_back(tensor);
228
229 SetCrops(OH_NN_INT64, m_crops_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_CROPS);
230 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
231 }
232
233 /**
234 * @tc.name: batch_to_space_nd_build_009
235 * @tc.desc: Verify the invalid param to batchtospace of the build function
236 * @tc.type: FUNC
237 */
238 HWTEST_F(BatchToSpaceNDBuilderTest, batch_to_space_nd_build_009, TestSize.Level1)
239 {
240 m_paramsIndex = m_params;
241 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
242 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
243
244 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT32, m_block_dim, nullptr,
245 OH_NN_CONV2D_STRIDES);
246 int64_t blockNum = 2;
247 int64_t* blockSizeValue = new (std::nothrow) int64_t[2]{2, 2};
248 EXPECT_NE(nullptr, blockSizeValue);
249 tensor->SetBuffer(blockSizeValue, sizeof(int64_t) * blockNum);
250
251 m_allTensors.emplace_back(tensor);
252 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
253 }
254
255 /**
256 * @tc.name: batch_to_space_nd_build_010
257 * @tc.desc: Verify the batchtospacend without set blocksize of the build function
258 * @tc.type: FUNC
259 */
260 HWTEST_F(BatchToSpaceNDBuilderTest, batch_to_space_nd_build_010, TestSize.Level1)
261 {
262 m_paramsIndex = m_params;
263 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
264 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
265
266 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT64, m_block_dim, nullptr,
267 OH_NN_BATCH_TO_SPACE_ND_BLOCKSIZE);
268 m_allTensors.emplace_back(tensor);
269
270 SetCrops(OH_NN_INT64, m_crops_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_CROPS);
271 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
272 }
273
274 /**
275 * @tc.name: batch_to_space_nd_build_011
276 * @tc.desc: Verify the batchtospacend without set crops of the build function
277 * @tc.type: FUNC
278 */
279 HWTEST_F(BatchToSpaceNDBuilderTest, batch_to_space_nd_build_011, TestSize.Level1)
280 {
281 m_paramsIndex = m_params;
282 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
283 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
284
285 SetBlockSize(OH_NN_INT64, m_block_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_BLOCKSIZE);
286 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT64, m_crops_dim, nullptr,
287 OH_NN_BATCH_TO_SPACE_ND_CROPS);
288 m_allTensors.emplace_back(tensor);
289 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
290 }
291
292 /**
293 * @tc.name: batch_to_space_nd_getprimitive_001
294 * @tc.desc: Verify the success of the GetPrimitive function
295 * @tc.type: FUNC
296 */
297 HWTEST_F(BatchToSpaceNDBuilderTest, batch_to_space_nd_getprimitive_001, TestSize.Level1)
298 {
299 m_paramsIndex = m_params;
300 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
301 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
302
303 SetBlockSize(OH_NN_INT64, m_block_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_BLOCKSIZE);
304 SetCrops(OH_NN_INT64, m_crops_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_CROPS);
305 EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
306 LiteGraphTensorPtr primitive = m_builder.GetPrimitive();
307 LiteGraphTensorPtr expectPrimitive = {nullptr, DestroyLiteGraphPrimitive};
308 EXPECT_NE(expectPrimitive, primitive);
309
310 std::vector<int64_t> blockSizeValue{2, 2};
311 std::vector<std::vector<int64_t>> cropsValue{{0, 0}, {0, 0}};
312 std::vector<int64_t> returnValue = mindspore::lite::MindIR_BatchToSpaceND_GetBlockShape(primitive.get());
313 EXPECT_EQ(returnValue, blockSizeValue);
314 std::vector<std::vector<int64_t>> cropsReturn = mindspore::lite::MindIR_BatchToSpaceND_GetCrops(primitive.get());
315 EXPECT_EQ(cropsReturn, cropsValue);
316 }
317
318 /**
319 * @tc.name: batch_to_space_nd_getprimitive_002
320 * @tc.desc: Verify the nullptr of the GetPrimitive function
321 * @tc.type: FUNC
322 */
323 HWTEST_F(BatchToSpaceNDBuilderTest, batch_to_space_nd_getprimitive_002, TestSize.Level1)
324 {
325 m_paramsIndex = m_params;
326 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
327 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
328
329 SetBlockSize(OH_NN_INT64, m_block_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_BLOCKSIZE);
330 SetCrops(OH_NN_INT64, m_crops_dim, nullptr, OH_NN_BATCH_TO_SPACE_ND_CROPS);
331
332 LiteGraphTensorPtr primitive = m_builder.GetPrimitive();
333 LiteGraphTensorPtr expectPrimitive = {nullptr, DestroyLiteGraphPrimitive};
334 EXPECT_EQ(expectPrimitive, primitive);
335 }
336 } // namespace UnitTest
337 } // namespace NeuralNetworkRuntime
338 } // namespace OHOS
339