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/space_to_batch_nd_builder.h"
17 
18 #include <gtest/gtest.h>
19 #include "nn_tensor.h"
20 #include "ops_test.h"
21 
22 using namespace testing;
23 using namespace testing::ext;
24 using namespace OHOS::NeuralNetworkRuntime::Ops;
25 
26 namespace OHOS {
27 namespace NeuralNetworkRuntime {
28 namespace UnitTest {
29 class SpaceToBatchNDBuilderTest : public OpsTest {
30 protected:
31     void InitTensor(const std::vector<uint32_t>& inputsIndex,
32         const std::vector<uint32_t>& outputsIndex) override;
33     void SaveBlockShapeTensor(OH_NN_DataType dataType, const std::vector<int32_t> &dim,
34         const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
35     void SavePaddingsTensor(OH_NN_DataType dataType, const std::vector<int32_t> &dim,
36         const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
37     void InitTensor(const std::vector<uint32_t>& inputsIndex, const std::vector<uint32_t>& outputsIndex,
38         const std::vector<uint32_t>& paramsIndex);
39 
40 protected:
41     SpaceToBatchNDBuilder m_builder;
42     std::vector<int64_t> m_expectBlockShapeValue;
43     std::vector<std::vector<int64_t>> m_expectPaddingsValue;
44 };
45 
InitTensor(const std::vector<uint32_t> & inputsIndex,const std::vector<uint32_t> & outputsIndex)46 void SpaceToBatchNDBuilderTest::InitTensor(const std::vector<uint32_t>& inputsIndex,
47     const std::vector<uint32_t>& outputsIndex)
48 {
49     std::vector<uint32_t> paramsIndex = { 2, 3 };
50     std::vector<int32_t> inputDim = {3, 2, 3};
51     std::vector<int32_t> OutputDim = {1, 1, 3};
52 
53     m_paramsIndex = paramsIndex;
54     SaveInputTensor(inputsIndex, OH_NN_FLOAT32, inputDim, nullptr);
55     SaveOutputTensor(outputsIndex, OH_NN_FLOAT32, OutputDim, nullptr);
56 }
57 
InitTensor(const std::vector<uint32_t> & inputsIndex,const std::vector<uint32_t> & outputsIndex,const std::vector<uint32_t> & paramsIndex)58 void SpaceToBatchNDBuilderTest::InitTensor(const std::vector<uint32_t>& inputsIndex,
59     const std::vector<uint32_t>& outputsIndex, const std::vector<uint32_t>& paramsIndex)
60 {
61     std::vector<int32_t> inputDim = {1, 2, 2, 1};
62     std::vector<int32_t> OutputDim = {4, 1, 1, 1};
63     std::vector<int32_t> shapeDim = {3};
64     std::vector<int32_t> paddingsDim = {2, 2};
65 
66     m_paramsIndex = paramsIndex;
67     SaveInputTensor(inputsIndex, OH_NN_FLOAT32, inputDim, nullptr);
68     SaveOutputTensor(outputsIndex, OH_NN_FLOAT32, OutputDim, nullptr);
69     SaveBlockShapeTensor(OH_NN_INT64, shapeDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_BLOCK_SHAPE);
70     SavePaddingsTensor(OH_NN_INT64, paddingsDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_PADDINGS);
71 }
72 
SaveBlockShapeTensor(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)73 void SpaceToBatchNDBuilderTest::SaveBlockShapeTensor(OH_NN_DataType dataType, const std::vector<int32_t> &dim,
74     const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
75 {
76     const int blockShapeLen = 2;
77     std::shared_ptr<NNTensor> blockShapeTensor = TransToNNTensor(dataType, dim, quantParam, type);
78     int64_t* blockShapeValue = new (std::nothrow) int64_t[blockShapeLen] {2, 2};
79     EXPECT_NE(nullptr, blockShapeValue);
80     blockShapeTensor->SetBuffer(blockShapeValue, sizeof(int64_t) * blockShapeLen);
81     m_allTensors.emplace_back(blockShapeTensor);
82     m_expectBlockShapeValue.assign(blockShapeValue, blockShapeValue + blockShapeLen);
83 }
84 
SavePaddingsTensor(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)85 void SpaceToBatchNDBuilderTest::SavePaddingsTensor(OH_NN_DataType dataType, const std::vector<int32_t> &dim,
86     const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
87 {
88     const int paddingsLen = 4;
89     const int row = 2;
90     const int col = 2;
91     std::shared_ptr<NNTensor> paddingsTensor = TransToNNTensor(dataType, dim, quantParam, type);
92     int64_t* paddingsValue = new (std::nothrow) int64_t[paddingsLen] {0, 0, 0, 0};
93     EXPECT_NE(nullptr, paddingsValue);
94     paddingsTensor->SetBuffer(paddingsValue, sizeof(int64_t) * paddingsLen);
95     m_allTensors.emplace_back(paddingsTensor);
96 
97     m_expectPaddingsValue.resize(row);
98     for (int i = 0; i < row; ++i) {
99         m_expectPaddingsValue[i].resize(col);
100     }
101 
102     int i = 0;
103     int j = 0;
104     for (int k = 0; k < paddingsLen; ++k) {
105         i = k / col;
106         j = k % col;
107         m_expectPaddingsValue[i][j] = paddingsValue[k];
108     }
109 }
110 
111 /**
112  * @tc.name: spacetobatchnd_build_001
113  * @tc.desc: Provide normal input, output, and parameters to verify the normal behavior of the Build function
114  * @tc.type: FUNC
115  */
116 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_build_001, TestSize.Level0)
117 {
118     std::vector<uint32_t> inputsIndex = { 0 };
119     std::vector<uint32_t> outputsIndex = { 1 };
120     std::vector<int32_t> shapeDim = {2};
121     std::vector<int32_t> paddingsDim = {2, 2};
122 
123     InitTensor(inputsIndex, outputsIndex);
124     SaveBlockShapeTensor(OH_NN_INT64, shapeDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_BLOCK_SHAPE);
125     SavePaddingsTensor(OH_NN_INT64, paddingsDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_PADDINGS);
126     OH_NN_ReturnCode ret = m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors);
127     EXPECT_EQ(OH_NN_SUCCESS, ret);
128 }
129 
130 /**
131  * @tc.name: spacetobatchnd_build_002
132  * @tc.desc: Call Build func twice to verify the abnormal behavior of the Build function
133  * @tc.type: FUNC
134  */
135 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_build_002, TestSize.Level0)
136 {
137     std::vector<uint32_t> inputsIndex = { 0 };
138     std::vector<uint32_t> outputsIndex = { 1 };
139     std::vector<int32_t> shapeDim = {2};
140     std::vector<int32_t> paddingsDim = {2, 2};
141 
142     InitTensor(inputsIndex, outputsIndex);
143 
144     SaveBlockShapeTensor(OH_NN_INT64, shapeDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_BLOCK_SHAPE);
145     SavePaddingsTensor(OH_NN_INT64, paddingsDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_PADDINGS);
146 
147     EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
148     OH_NN_ReturnCode ret = m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors);
149     EXPECT_EQ(OH_NN_OPERATION_FORBIDDEN, ret);
150 }
151 
152 /**
153  * @tc.name: spacetobatchnd_build_003
154  * @tc.desc: Provide one more than normal input to verify the abnormal behavior of the Build function
155  * @tc.type: FUNC
156  */
157 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_build_003, TestSize.Level0)
158 {
159     std::vector<uint32_t> inputsIndex = { 0, 1, 2, 3 };
160     std::vector<uint32_t> outputsIndex = { 4 };
161     std::vector<int32_t> shapeDim = {2};
162     std::vector<int32_t> paddingsDim = {2, 2};
163 
164     InitTensor(inputsIndex, outputsIndex);
165     SaveBlockShapeTensor(OH_NN_INT64, shapeDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_BLOCK_SHAPE);
166     SavePaddingsTensor(OH_NN_INT64, paddingsDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_PADDINGS);
167 
168     OH_NN_ReturnCode ret = m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors);
169     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
170 }
171 
172 /**
173  * @tc.name: spacetobatchnd_build_004
174  * @tc.desc: Provide one more than normal output to verify the abnormal behavior of the Build function
175  * @tc.type: FUNC
176  */
177 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_build_004, TestSize.Level0)
178 {
179     std::vector<uint32_t> inputsIndex = { 0 };
180     std::vector<uint32_t> outputsIndex = { 1, 2 };
181     std::vector<int32_t> shapeDim = {2};
182     std::vector<int32_t> paddingsDim = {2, 2};
183 
184     InitTensor(inputsIndex, outputsIndex);
185     SaveBlockShapeTensor(OH_NN_INT64, shapeDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_BLOCK_SHAPE);
186     SavePaddingsTensor(OH_NN_INT64, paddingsDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_PADDINGS);
187 
188     OH_NN_ReturnCode ret = m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors);
189     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
190 }
191 
192 /**
193  * @tc.name: spacetobatchnd_build_005
194  * @tc.desc:  Provide empty input to verify the abnormal behavior of the Build function
195  * @tc.type: FUNC
196  */
197 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_build_005, TestSize.Level0)
198 {
199     std::vector<uint32_t> inputsIndex = {};
200     std::vector<uint32_t> outputsIndex = {};
201     std::vector<int32_t> shapeDim = {2};
202     std::vector<int32_t> paddingsDim = {2, 2};
203 
204     InitTensor(inputsIndex, outputsIndex);
205     SaveBlockShapeTensor(OH_NN_INT64, shapeDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_BLOCK_SHAPE);
206     SavePaddingsTensor(OH_NN_INT64, paddingsDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_PADDINGS);
207 
208     OH_NN_ReturnCode ret = m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors);
209     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
210 }
211 
212 /**
213  * @tc.name: spacetobatchnd_build_006
214  * @tc.desc: Provide param type error to verify the abnormal behavior of the Build function
215  * @tc.type: FUNC
216  */
217 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_build_006, TestSize.Level0)
218 {
219     std::vector<uint32_t> inputsIndex = { 0 };
220     std::vector<uint32_t> outputsIndex = { 1 };
221     std::vector<int32_t> shapeDim = {2};
222     std::vector<int32_t> paddingsDim = {2, 2};
223 
224     InitTensor(inputsIndex, outputsIndex);
225 
226     SaveBlockShapeTensor(OH_NN_INT32, shapeDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_BLOCK_SHAPE);
227     SavePaddingsTensor(OH_NN_INT64, paddingsDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_PADDINGS);
228 
229     OH_NN_ReturnCode ret = m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors);
230     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
231 }
232 
233 /**
234  * @tc.name: spacetobatchnd_build_007
235  * @tc.desc: Provide param type error to verify the abnormal behavior of the Build function
236  * @tc.type: FUNC
237  */
238 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_build_007, TestSize.Level0)
239 {
240     std::vector<uint32_t> inputsIndex = { 0 };
241     std::vector<uint32_t> outputsIndex = { 1 };
242     std::vector<int32_t> shapeDim = {2};
243     std::vector<int32_t> paddingsDim = {2, 2};
244 
245     InitTensor(inputsIndex, outputsIndex);
246 
247     SaveBlockShapeTensor(OH_NN_INT64, shapeDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_BLOCK_SHAPE);
248     SavePaddingsTensor(OH_NN_INT32, paddingsDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_PADDINGS);
249 
250     OH_NN_ReturnCode ret = m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors);
251     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
252 }
253 
254 /**
255  * @tc.name: spacetobatchnd_build_008
256  * @tc.desc: Provide input dimensions error to verify the abnormal behavior of the Build function
257  * @tc.type: FUNC
258  */
259 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_build_008, TestSize.Level0)
260 {
261     std::vector<uint32_t> inputsIndex = { 0 };
262     std::vector<uint32_t> outputsIndex = { 1 };
263     std::vector<uint32_t> paramsIndex = { 2, 3 };
264     InitTensor(inputsIndex, outputsIndex, paramsIndex);
265 
266     OH_NN_ReturnCode ret = m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors);
267     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
268 }
269 
270 /**
271  * @tc.name: spacetobatchnd_build_009
272  * @tc.desc: Provide output dimensions error to verify the abnormal behavior of the Build function
273  * @tc.type: FUNC
274  */
275 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_build_009, TestSize.Level0)
276 {
277     std::vector<uint32_t> inputsIndex = { 0 };
278     std::vector<uint32_t> outputsIndex = { 1 };
279     std::vector<uint32_t> paramsIndex = { 2, 3 };
280     InitTensor(inputsIndex, outputsIndex, paramsIndex);
281 
282     OH_NN_ReturnCode ret = m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors);
283     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
284 }
285 
286 /**
287  * @tc.name: spacetobatchnd_build_010
288  * @tc.desc: Provide empty output to verify the normal behavior of the Build function
289  * @tc.type: FUNC
290  */
291 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_build_0010, TestSize.Level0)
292 {
293     std::vector<uint32_t> inputsIndex = { 0 };
294     std::vector<uint32_t> outputsIndex = {};
295     std::vector<uint32_t> paramsIndex = { 1, 2 };
296 
297     InitTensor(inputsIndex, outputsIndex, paramsIndex);
298     OH_NN_ReturnCode ret = m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors);
299     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
300 }
301 
302 /**
303  * @tc.name: spacetobatchnd_build_011
304  * @tc.desc: Provide block shape parameter buffer is nullptr to verify the abnormal behavior of the Build function
305  * @tc.type: FUNC
306  */
307 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_build_011, TestSize.Level0)
308 {
309     std::vector<uint32_t> inputsIndex = { 0 };
310     std::vector<uint32_t> outputsIndex = { 1 };
311     std::vector<int32_t> shapeDim = {2};
312     std::vector<int32_t> paddingsDim = {2, 2};
313 
314     InitTensor(inputsIndex, outputsIndex);
315     std::shared_ptr<NNTensor> blockShapeTensor = TransToNNTensor(OH_NN_INT64, shapeDim, nullptr,
316         OH_NN_SPACE_TO_BATCH_ND_BLOCK_SHAPE);
317     blockShapeTensor->SetBuffer(nullptr, 0);
318     m_allTensors.emplace_back(blockShapeTensor);
319 
320     SavePaddingsTensor(OH_NN_INT64, paddingsDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_PADDINGS);
321 
322     OH_NN_ReturnCode ret = m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors);
323     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
324 }
325 
326 /**
327  * @tc.name: spacetobatchnd_build_012
328  * @tc.desc: Provide paddings parameter buffer is nullptr to verify the abnormal behavior of the Build function
329  * @tc.type: FUNC
330  */
331 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_build_012, TestSize.Level0)
332 {
333     std::vector<uint32_t> inputsIndex = { 0 };
334     std::vector<uint32_t> outputsIndex = { 1 };
335     std::vector<int32_t> shapeDim = {2};
336     std::vector<int32_t> paddingsDim = {2, 2};
337 
338     InitTensor(inputsIndex, outputsIndex);
339     SaveBlockShapeTensor(OH_NN_INT64, shapeDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_BLOCK_SHAPE);
340 
341     std::shared_ptr<NNTensor> blockShapeTensor = TransToNNTensor(OH_NN_INT64, paddingsDim, nullptr,
342         OH_NN_SPACE_TO_BATCH_ND_PADDINGS);
343     blockShapeTensor->SetBuffer(nullptr, 0);
344     m_allTensors.emplace_back(blockShapeTensor);
345 
346     OH_NN_ReturnCode ret = m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors);
347     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
348 }
349 
350 /**
351  * @tc.name: spacetobatchnd_build_013
352  * @tc.desc: Provide invalid parameter type to verify the abnormal behavior of the Build function
353  * @tc.type: FUNC
354  */
355 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_build_013, TestSize.Level0)
356 {
357     std::vector<uint32_t> inputsIndex = { 0 };
358     std::vector<uint32_t> outputsIndex = { 1 };
359     std::vector<int32_t> shapeDim = {2};
360     std::vector<int32_t> paddingsDim = {2, 2};
361 
362     InitTensor(inputsIndex, outputsIndex);
363     SaveBlockShapeTensor(OH_NN_INT64, shapeDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_BLOCK_SHAPE);
364     SavePaddingsTensor(OH_NN_INT64, paddingsDim, nullptr, OH_NN_SCALE_AXIS);
365 
366     OH_NN_ReturnCode ret = m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors);
367     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
368 }
369 
370 /**
371  * @tc.name: spacetobatchnd_build_014
372  * @tc.desc: Provide block shape parameter dimension error to verify the abnormal behavior of the Build function
373  * @tc.type: FUNC
374  */
375 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_build_014, TestSize.Level0)
376 {
377     std::vector<uint32_t> inputsIndex = { 0 };
378     std::vector<uint32_t> outputsIndex = { 1 };
379     std::vector<int32_t> shapeDim = {2, 3};
380     std::vector<int32_t> paddingsDim = {2, 2};
381 
382     InitTensor(inputsIndex, outputsIndex);
383     SaveBlockShapeTensor(OH_NN_INT64, shapeDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_BLOCK_SHAPE);
384     SavePaddingsTensor(OH_NN_INT64, paddingsDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_PADDINGS);
385 
386     OH_NN_ReturnCode ret = m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors);
387     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
388 }
389 
390 /**
391  * @tc.name: spacetobatchnd_build_015
392  * @tc.desc: Provide paddings parameter dimension error to verify the abnormal behavior of the Build function
393  * @tc.type: FUNC
394  */
395 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_build_015, TestSize.Level0)
396 {
397     std::vector<uint32_t> inputsIndex = { 0 };
398     std::vector<uint32_t> outputsIndex = { 1 };
399     std::vector<int32_t> shapeDim = {2};
400     std::vector<int32_t> paddingsDim = {2, 2, 2};
401 
402     InitTensor(inputsIndex, outputsIndex);
403     SaveBlockShapeTensor(OH_NN_INT64, shapeDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_BLOCK_SHAPE);
404     SavePaddingsTensor(OH_NN_INT64, paddingsDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_PADDINGS);
405 
406     OH_NN_ReturnCode ret = m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors);
407     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
408 }
409 
410 /**
411  * @tc.name: spacetobatchnd_build_016
412  * @tc.desc: Provide paddings parameter dimension error to verify the abnormal behavior of the Build function
413  * @tc.type: FUNC
414  */
415 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_build_016, TestSize.Level0)
416 {
417     std::vector<uint32_t> inputsIndex = { 0 };
418     std::vector<uint32_t> outputsIndex = { 1 };
419     std::vector<int32_t> shapeDim = {2};
420     std::vector<int32_t> paddingsDim = {2, 3};
421 
422     InitTensor(inputsIndex, outputsIndex);
423     SaveBlockShapeTensor(OH_NN_INT64, shapeDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_BLOCK_SHAPE);
424 
425     const int paddingsLen = 6;
426     std::shared_ptr<NNTensor> paddingsTensor = TransToNNTensor(OH_NN_INT64, paddingsDim, nullptr,
427         OH_NN_SPACE_TO_BATCH_ND_PADDINGS);
428     int64_t* paddingsValue = new (std::nothrow) int64_t[paddingsLen] {0, 0, 0, 0, 0, 0};
429     EXPECT_NE(nullptr, paddingsValue);
430     paddingsTensor->SetBuffer(paddingsValue, sizeof(int64_t) * paddingsLen);
431     m_allTensors.emplace_back(paddingsTensor);
432 
433     OH_NN_ReturnCode ret = m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors);
434     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
435 }
436 
437 /**
438  * @tc.name: spacetobatchnd_getprimitive_001
439  * @tc.desc: Verify the GetPrimitive function return nullptr
440  * @tc.type: FUNC
441  */
442 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_getprimitive_001, TestSize.Level0)
443 {
444     LiteGraphTensorPtr primitive = m_builder.GetPrimitive();
445     LiteGraphTensorPtr expectPrimitive(nullptr, DestroyLiteGraphPrimitive);
446     EXPECT_EQ(primitive, expectPrimitive);
447 }
448 
449 /**
450  * @tc.name: spacetobatchnd_getprimitive_002
451  * @tc.desc: Verify the normal params return behavior of the getprimitive function
452  * @tc.type: FUNC
453  */
454 HWTEST_F(SpaceToBatchNDBuilderTest, spacetobatchnd_getprimitive_002, TestSize.Level0)
455 {
456     std::vector<uint32_t> inputsIndex = { 0 };
457     std::vector<uint32_t> outputsIndex = { 1 };
458     std::vector<int32_t> shapeDim = {2};
459     std::vector<int32_t> paddingsDim = {2, 2};
460 
461     InitTensor(inputsIndex, outputsIndex);
462     SaveBlockShapeTensor(OH_NN_INT64, shapeDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_BLOCK_SHAPE);
463     SavePaddingsTensor(OH_NN_INT64, paddingsDim, nullptr, OH_NN_SPACE_TO_BATCH_ND_PADDINGS);
464 
465     EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
466     LiteGraphTensorPtr primitive = m_builder.GetPrimitive();
467     LiteGraphTensorPtr expectPrimitive(nullptr, DestroyLiteGraphPrimitive);
468     EXPECT_NE(primitive, expectPrimitive);
469 
470     auto returnValue = mindspore::lite::MindIR_SpaceToBatchND_GetPaddings(primitive.get());
471     auto returnValueSize = returnValue.size();
472     for (size_t i = 0; i < returnValueSize; ++i) {
473         auto k = returnValue[i].size();
474         for (size_t j = 0; j < k; ++j) {
475             EXPECT_EQ(returnValue[i][j], m_expectPaddingsValue[i][j]);
476         }
477     }
478 
479     auto returnBlockShape = mindspore::lite::MindIR_SpaceToBatchND_GetBlockShape(primitive.get());
480     auto returnBlockShapeSize = returnBlockShape.size();
481     for (size_t i = 0; i < returnBlockShapeSize; ++i) {
482         EXPECT_EQ(returnBlockShape[i], m_expectBlockShapeValue[i]);
483     }
484 }
485 } // namespace UnitTest
486 } // namespace NeuralNetworkRuntime
487 } // namespace OHOS
488